Draft ECMA-262 / February 21, 2018

)

表示非终止符 WhileStatement 可以代表：token while，其后跟左括号 token，其后跟 Expression，其后跟右括号 token，其后跟 Statement。这里出现的 Expression and Statement 本身也是非终止符。另一个例子，句法定义：

表示非终止符 ArgumentList 可以代表，一个 AssignmentExpression；或者一个 ArgumentList，其后跟一个逗号，其后跟一个 AssignmentExpression。ArgumentList 的定义是递归的，也就是说，它定义它自身。其结果是，一个 ArgumentList 可能包含用逗号分隔开的任意正数个参数，其中，每个参数表达式都是一个 AssignmentExpression。这样，非终止符共用了递归的定义。

终止符或非终止符的后面，可能会出现后缀下标 “opt”，表示它是一个可选的符号。实际上，含有可选符号的替代子包含两个右边部分，一个是省略可选元素的，另一个是包含可选元素的。即：

opt

是下面的一种简写方式:

并且:

for

(

opt

;

opt

)

是下面的一种简写方式:

for

(

;

opt

)

for

(

;

opt

)

或是下面的另一种简写方式:

for

(

;

)

for

(

;

)

for

(

;

)

for

(

;

)

因此，在本例中，非终止符 IterationStatement 实际上有四种可替代的右边。

生成式也可能会被一个下标式的注解给参数化，形如 “_[parameters]”，会作为一个后缀，出现在生成式定义的非终止符的后面。“_parameters” 可能是一个单独的名字或是由一个逗号分隔的名字列表。参数化生成式是一组生成式的简写，这组生成式定义了参数名的所有组合，参数名前面有一个下划线前缀，并和参数名一起被附加到参数化非终止符的后面。即：

[Return]

是一个简写形式：

和：

[Return, In]

是一个简写形式：

StatementList_Return_In

多个参数可以产生若干个可组合的生成式，但，并非所有的生成式都能在一个完整的文法中被引用。

对于一个生成式右边的非终止符的引用，也可以被参数化，例如：

[+In]

相当于：

ExpressionStatement_In

和：

[~In]

相当于：

一个非终止符的引用也可以同时包含一个参数列表和一个 “_opt” 下标。例如：

[+In]

opt

是一种简写形式：

Initializer_In

如果，在一个非终止符引用的右边加上一个带 “_?” 前缀的参数名，那么，该参数值的存在，取决于当前生成式的左边符号引用上的相同参数名是否出现。例如：

[In]

[?In]

是一种简写形式：

VariableDeclaration_In

Initializer_In

如果一个替代子的右边有前缀 “[+parameter]”，那么该替代子是否可用，取决于该生成式的左边非终止符的引用上是否存在相同的参数名。如果一个替代子右边有前缀 “[~parameter]”，那么，其行为与上面的描述完全相反。即：

[Return]

[+Return]

是一个缩写形式：

和：

[Return]

[~Return]

是一个缩写形式：

如果一个文法定义的冒号后面出现 “one of”，则标志着其后面的一行或多行中出现的每个终止符都是一个替代子的定义。例如，ES 词法包含的生成式：

one of

这仅仅是下面写法的一种简写:

如果生成式的右边出现 “[empty]”，则表明，该生成式的右边不包含任何终止符或非终止符。

若一个生成式的右边出现 “[lookahead ∉ set]”，则表明，如果紧随该生成式后的 token 是给定 set 中的成员，那么该生成式不能被使用。这个 set 可以写成一个大括号括起来的被逗号分隔的终止符列表。为方便起见，set 也可以写成一个非终止符，在这种情况下，它代表了该非终止符所能扩展的，所有终止符的集合。如果这个集合只由一个单一的终止符组成，那么可以直接使用 “[lookahead ≠ terminal]” 来表示。

例如，定义:

one of

该定义：

[lookahead ∉ { 1, 3, 5, 7, 9 }]

[lookahead ∉ DecimalDigit]

匹配字母 n 后跟随由偶数起始的一个或多个十进制数字；或一个十进制数字后面跟随一个非十进制数字。

类似地，若一个生成式的右边出现 “[lookahead ∈ set]”，则表明，如果紧随该生成式后的 token 是给定 set 中的成员，那么该生成式才能被使用。如果这个 set 只由一个单一的终止符组成，那么可以使用 “[lookahead = terminal]” 表示。

如果一个生成式的右边出现 “[no LineTerminator here]”，那么，它表示此生成式是一个受限的生成式：如果 LineTerminator 在输入流的指定位置出现，那么，此生成式将不会被使用。例如，生成式：

throw

[no LineTerminator here]

;

表明，若一个行终止符，出现在 throw token 和 Expression 的脚本之间，则该生成式不能被使用。

除非行终止符的出现，被受限制的生成式禁止，否则，行终止符可以在输入元素流的任何两个 tokens 之间出现任意次数，且不会影响程序的语法验证。

当词法或数值型字符串文法中的一个生成式的替代子，似乎是一个多码点的 token 时，它表示构成这种 token 的码点序列。

生成式的右侧可以通过短语 “but not” 来指定某些扩展是不允许使用的，该短语的后面指出要排除的扩展。例如，生成式：

but not ReservedWord

意味着非终止符 Identifier，可以用能被 IdentifierName 代替的任何码点序列所替换，前提是这些相同的码点序列不能替换 ReservedWord。

最后，在一些无法列出所有替代子的情况下，可以用 sans-serif（无衬线字体）类型的描述性短语来描述这些非终止符：

any Unicode code point

5.2算法约定

本规范使用带编号的列表，来指定一个算法的步骤。这些算法被用来，精确地指定 ES 语言的构建块所需的语义。这些算法，无意暗示使用任何具体的实现技术。在实践中，也许存在更高效的算法来实现一个给定的功能。

在一些案例中，算法可能被显示地参数化，这种情况下，参数的名字和用法必须被提供，以作为算法定义的一部分。

某些算法的步骤可再细分为有序的子步骤。子步骤会被缩进，或者可以将自身进一步划分为缩进的子步骤。编号化约定的大纲，用于识别子步骤，第一级子步骤使用小写字母标记，第二级子步骤使用小写罗马数字标记。如果需要超过三个层次，则重复这些规则，第四层次使用数字标记。例如 :

Top-level step
1. Substep.
2. Substep.
  1. Subsubstep.
    1. Subsubsubstep
      1. Subsubsubsubstep
        Subsubsubsubsubstep

一个步骤或子步骤可使用预测符 “如果” 来限制其子步骤。在这种情况下，当预测为真时，子步骤才能被使用。如果一个步骤或子步骤由 “否则” 开始，那么它也是一个预测，否定前面的同一层级的 “如果” 预测。

一个步骤可以为其子步骤指定迭代应用。

以 “Assert:” 开头的步骤，用来断言其算法的不变量条件。这样的断言被用来生成显式的算法不变量（在某些情况下可能是是隐式的）。这样的断言不会增加额外的语义要求，因此不需要通过实现来检查。它们仅用于明晰算法。

算法步骤可以为任何的值，声明一个别名，形如 “Let x be someValue”。这些别名与引用是类似的，因为 x 和 someValue 都指向相同的底层数据，且数据的修改对两者都是可见的。如果想要避免类似引用的行为，那么，算法步骤应该明确地创建一个 someValue 的副本：例如，“Let x be a copy of someValue” 可以创建一个 someValue 的浅拷贝。

一旦别名被声明，可以在任何后续步骤中引用它，但不得在该别名声明之前的步骤中引用它。可以使用 “Set x to someOtherValue” 的形式对别名进行修改。

5.2.1抽象操作

为了在本文档的多个部分方便抽象操作的使用，一些叫做抽象操作的算法，被命名和书写成带参数的函数形式，以便它们可以被其它包含该名字的算法复用。抽象操作可以以一个函数的应用形式（例如，OperationName(arg1, arg2)）被引用。一些抽象操作可以被当做是，一种类似 class 的规范抽象的多形态分配方法。这样的类似 method 的抽象操作，可以以一种方法的应用形式（例如，someValue.OperationName(arg1, arg2)）被引用。

5.2.2句法导向的操作

句法导向的操作是一种被命名的操作，它的定义由算法组成，每一个算法都和 ES 文法中的一个或多个生成式相关联。一个有多种替代子定义的生成式，都会存在一个严格区别的算法与之对应。当一个算法与一个文法生成式相关联，它或许会引用可选生成式的终止符或非终止符，就相当于它们是算法的参数一样。当以这样的一种方式使用时，非终止符会在解析源文本时，参考实际的可选定义来与之匹配。

当一个算法与一个可选生成式项关联时，这个可选生成式会以没有任何 “[ ]” 的文法注解的形式显示。这样的注解只会影响可选生成式的句法识别，而不会影响可用生成式的关联语义。

句法导向的操作会以一个解析节点和，在下面算法的步骤 1、3、4 中，被用作约定的其它参数（可选），的形式被调用：

Let status be the result of performing SyntaxDirectedOperation of SomeNonTerminal.
Let someParseNode be the parse of some source text.
Perform SyntaxDirectedOperation of someParseNode.
Perform SyntaxDirectedOperation of someParseNode passing "value" as the argument.

除非显式指定，否则所有的链式生成式，对每个操作都有一个隐式的定义，即每个操作都可能被应用到该生成式的左边 - 非终止符。隐式定义会简单地，把携带有相同参数的相同操作（如果有的话），重复应用到链式生成式的唯一的右边 - 非终止符，然后返回结果。例如，假设某些算法有一个形如：“Return the result of evaluating Block” 的步骤，如这个生成式：

{

}

但该估值操作并没有把一个算法与该生成式关联起来。这种情况下，估值操作会隐式地包含一个关联，形如：

SS: 估值

{

StrUnsignedDecimalLiteral

}

Return the result of evaluating StatementList.

5.2.3运行时语义

必须在运行时被调用才能确定语义的算法，叫做运行时语义。运行时语义由抽象操作或句法导向的操作定义。这类算法总是返回一个完成记录。

5.2.3.1隐式完成值

本规范的算法经常隐式地返回，其 [[Type]] 是 normal 的完成记录。除非上下文中有明显的显示，否则算法语句返回一个不是完成记录的值，例如：

Return "Infinity".

等同于：

Return NormalCompletion("Infinity").

但是，如果 “return” 语句的值表达式是一个完成记录构造字面量，则返回这个完成记录的结果。如果值表达式是一个对抽象操作的调用，则 “return” 语句只会简单地返回，由抽象操作生成的完成记录。

抽象操作 Completion(completionRecord) 用来强调，其返回的是一个原先的被计算的完成记录。该 Completion 抽象操作只携带一个单独的参数 completionRecord，执行如下：

Assert: completionRecord is a Completion Record.
Return completionRecord as the Completion Record of this abstract operation.

在算法步骤中。一个没有值的 “return” 语句意味着：

Return NormalCompletion(undefined).

对于未显式要求一个完整完成记录值的上下文中的，完成记录值的任何引用，其相当于对完成记录值的 [[Value]] 字段的显式引用，除非完成记录是一个突然完成。

5.2.3.2抛出一个异常

一个抛出异常的算法步骤，例如

抛出一个 TypeError 异常.

等同于：

Return Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.

5.2.3.3ReturnIfAbrupt

算法步骤，形如：

ReturnIfAbrupt(argument).

等同于：

If argument is an abrupt completion, return argument.
Else if argument is a Completion Record, let argument be argument.[[Value]].

算法步骤，形如：

ReturnIfAbrupt(AbstractOperation()).

等同于：

Let hygienicTemp be AbstractOperation().
If hygienicTemp is an abrupt completion, return hygienicTemp.
Else if hygienicTemp is a Completion Record, let hygienicTemp be hygienicTemp.[[Value]].

其中的 hygienicTemp，仅在关于 ReturnIfAbrupt 的步骤中，是短暂可见的。

另一个算法步骤：

Let result be AbstractOperation(ReturnIfAbrupt(argument)).

等同于:

If argument is an abrupt completion, return argument.
If argument is a Completion Record, let argument be argument.[[Value]].
Let result be AbstractOperation(argument).

5.2.3.4ReturnIfAbrupt 速记符

带有前缀 ? 的抽象操作和句法导向操作的调用，表明 ReturnIfAbrupt 应该被应用到能返回完成记录的操作中。例如，步骤：

? OperationName().

等同于:

ReturnIfAbrupt(OperationName()).

方法形式的调用也一样，如步骤：

? someValue.OperationName().

等同于：

ReturnIfAbrupt(someValue.OperationName()).

类似地，前缀 ! 用于指示以下，永远不会返回一个结果为突然完成的，抽象或句法导向操作的调用，并且完成记录 [[Value]] 字段的结果应该用来代替该操作的返回值。例如，步骤：

Let val be ! OperationName().

等同于以下步骤：

Let val be OperationName().
Assert: val is never an abrupt completion.
If val is a Completion Record, set val to val.[[Value]].

对于运行时语义来说，句法导向操作会在其的调用之前，充分使用速记符 ! 或 ?：

Perform ! SyntaxDirectedOperation of NonTerminal.

5.2.4静态语义

上下文无关文法，不足以强有力的表达所有规则（定义了输入元素流是否可以形成可被评估的有效 ES 脚本或模块）。在某些情况下，需要使用 ES 算法约定或 prose 要求，所表达的附加规则。这些规则总是与文法的生成式相关联，并被称为该生成式的静态语义。

静态语义规则具有名字，且通常由一个算法定义。命名的静态语义规则通常会与一个文法生成式相关联，并且，对于一个具有多个可选定义的生成式而言，通常，每个可选定义，都存在一个，针对每个可被应用的命名静态语义规则的，不同算法。

除非另有说明，否则本规范中的每个文法生成式的替代者，都隐式地有一个名为 Contains 的静态语义规则的定义，其包含一个名为 symbol 的参数（参数值是一个，包含关联生成式文法的终止符或非终止符）。Contains 的默认定义如下：

For each child node child of this Parse Node, do
1. If child is an instance of symbol, return true.
2. If child is an instance of a nonterminal, then
  1. Let contained be the result of child Contains symbol.
  2. If contained is true, return true.
Return false.

上述定义会被特定的生成式，显式地覆盖。

有一种特定类型的静态语义规则叫做是早期错误规则。早期错误规则定义了与特定文法生成式相关的早期错误条件（参见条款 16）。早期错误规则的估值，并没有被本规范中的算法所显式地调用。一个一致的实现，必须在对脚本或模块进行首次估值之前，验证所有用于解析该脚本或模块的生成式的早期错误规则。若违反了任何早期错误规则，则该脚本或模块是无效且无法被评估。

5.2.5数学运算

数学运算，如加法，减法，负数，乘法，除法和数学函数（定义在后续条款中），应该总是被理解为，基于数学实数的可计算的精确的数学结果。除非另有说明，否则该结果，不包括无穷大，且不包括负零（与正零相区别）。本标准中，模拟浮点运算的算法，在必要时，会包含明确的步骤，以处理无穷大和带符号零以及执行舍入。如果将一个数学运算或函数应用于浮点数，那么，它会被理解为，由该浮点数表示的精确数学值；这样的一个浮点数必须是有限的，且，如果它是 +0 或 -0，那么相应的数学值就是一个单一的 0。

数学函数 abs(x) 会产生 x 的一个绝对值，若 x 是一个负数，则该绝对值为 -x；否则为 x 自身。

数学函数 min(x1, x2, ..., xN) 会产生一个，从 x1 到 xN 中的，最小的数学值；数学函数 max(x1, x2, ..., xN) 则相反，取其中的最大值。这些数学函数的值域范围包含+∞ 和 -∞。

“x modulo y” (y 必须是一个有限的且非零的数) 会计算得到一个值 k，该值与 y （可以为 0）具有相同的符号，且满足 abs(k) < abs(y)，且对于某个整数 q 满足 x-k = q × y。

数学函数 floor(x) 会产生一个，不会大于 x 的最大整数（接近正无穷）。

Note

floor(x) = x-(x modulo 1).

6ES 数据类型和值

在本规范中，算法操作的每一个值，都存在一个与之相关的类型。这些可能的值类型，被精确地定义在本条款中。类型可以被进一步的细分为 ES 语言类型和规范类型。

在本规范中，符号 “Type(x)” 是 “the type of x” 的简写形式，“type” 是对定义在本条款中的 ES 语言类型和规范类型的引用。当术语 “empty” 被使用来作为一个值时，它表示 “no value of any type”。

6.1ES 语言类型

ES 语言类型对应于那些能够被 ES 程序员所直接操作的值。ES 语言类型包括 Undefined、Null、Boolean、String、Symbol、Number 和 Object。一个 ES 语言值是一个被 ES 语言类型特征化的值。

6.1.1Undefined 类型

Undefined 类型有且只有一个值，称为 undefined 。任何没有被赋值的变量的值都是 undefined。

6.1.2Null 类型

Null 类型有且只有一个值，称为 null。

6.1.3Boolean 类型

Boolean 类型表示逻辑实体，有两个值，称为 true 和 false。

6.1.4String 类型

字符串类型是，由零个或多个（最多有 2⁵³-1 个）16 位无符号整数值（“元素”）组成的，所有有序序列的集合。在一个运行的 ES 程序中，字符串类型常被用于表示文本数据，此时字符串中的每个元素都被视为一个 UTF-16 码点值。每个元素都被认为占有此序列中的一个位置，可以用非负数的整数值来索引这些位置。第一个元素（若存在）在位置 0，下一个元素（若存在）在位置 1，依此类推。字符串的长度即其中元素（比如，16 位值）的个数。空字符串长度为零，故不包含任何元素。

当 ES 操作，对字符串值进行解释时，每个元素都会被认为是一个单独的 UTF-16 代码单元。但是，ES 语言并没有对字符串值中的代码单元序列做任何的限制或要求，所以，当字符串值被作为 UTF-16 代码单元解释时，它们可能是非正式的。不解释字符串内容的操作，会把它们视为无差别的 16 无符号整数来处理。String.prototype.normalize (见 21.1.3.12) 函数可以用来显示地标准化一个字符串值；而 String.prototype.localeCompare (see21.1.3.10) 函数可以在语言内部标准化字符串值；但是没有其他操作，隐式地标准化它们操作的字符串。只有这些被明确指定为语言或区域敏感的操作，才会产生语言敏感的结果。

Note

这样设计的理由是为了尽可能地保持字符串实现的简单和高效。如何 ES 源文本是 Normalized Form C，那么，尽管它们不包括任何的 Unicode 转译序列，字符串字面量也必须保证是 Normalized。

一些情况下，ES 操作会把字符串内容作为 UTF-16 编码的 Unicode 代码单元来解释。例如：

在 0 到 0xD7FF 或 0xE000 到 0xFFFF 范围内的代码单元会被解释为一个具有相同值的码点。
一个由两个代码单元组成的序列（其中第一个代码单元 c1 的范围在 0xD800 到 0xDBFF 之间，第二个代码单元 c2 的范围在 0xDC00 到 0xDFFF 之间），是一个代理对，且会被解释为一个值是 (c1 - 0xD800) × 0x400 + (c2 - 0xDC00) + 0x10000 的码点。 (见 10.1.2)
一个在 0xD800 到 0xDFFF 范围内但不是一个代理对的部分的代码单元，会被解释为具有相同值的码点。

在本规范中，短语 "the string-concatenation of A, B, ..." (其中，每一个参数都是一个 String 值或代码单元或一串代码单元) 表示一个 String 值，该值是由每个参数（按顺序排列）的代码单元（按顺序排列）组成的序列。

6.1.5Symbol 类型

Symbol 类型是，可以用作对象属性键 (6.1.7) 但不是 String 值的，所有值的集合。

每个可能的 Symbol 值都是唯一的且不可改变的。

每个 Symbol 值都会一直存在一个关联值，叫做 [[Description]]，其值是一个 String 值或 undefined。

6.1.5.1众所周知的符号

众所周知的符号是一些，被本规范的算法显式引用的，内置 Symbol 值。它们通常被用作属性键，其值被作为一个规范算法的扩展点。除非另有说明，否则众所周知的符号值被所有范围 (8.2) 所共享。

在本规范中，一个众所周知的符号，是用一个形如 @@name 的形式标记来引用的，其中的 “name” 是表 1 中所列出的值之一。

Table 1: 众所周知的符号

规范名	[[Description]]	值和目的
@@asyncIterator	`"Symbol.asyncIterator"`	一个方法，返回一个对象的默认 AsyncIterator。由 `for`-`await`-`of` 语句的语义调用。
@@hasInstance	`"Symbol.hasInstance"`	一个方法，判定一个构造器对象是否能识别一个作为其构造器实例之一的对象。由 `instanceof` 运算符的语义调用。
@@isConcatSpreadable	`"Symbol.isConcatSpreadable"`	一个 Boolean 值属性，若值为 true，则表明，一个对象可以通过 `Array.prototype.concat` 将其扁平化为它的数组元素。
@@迭代器	`"Symbol.迭代器"`	一个方法，返回一个对象的默认 Iterator。由 for-of 语句的语义调用。
@@match	`"Symbol.match"`	一个正则表达式的方法，对一个字符串执行正则匹配。由 `String.prototype.match` 方法调用。
@@replace	`"Symbol.replace"`	一个正则表达式的方法，替换一个字符串中被匹配到的子串。由 `String.prototype.replace` 方法调用。
@@search	`"Symbol.search"`	一个正则表达式的方法，返回一个字符串中被匹配到的值的索引。由 `String.prototype.search` 方法调用。
@@species	`"Symbol.species"`	一个方法值属性，是一个构造器函数，用来创建一个派生对象。
@@split	`"Symbol.split"`	一个正则表达式的方法，分割出一个被正则表达式匹配的字符串。由 `String.prototype.split` 方法调用。
@@toPrimitive	`"Symbol.toPrimitive"`	一个方法，将对象转换为一个对应的原始值. 由 ToPrimitive 抽象操作调用。
@@toStringTag	`"Symbol.toStringTag"`	一个 String 的值属性，被用于一个对象的默认字符串描述的创建。由内置方法 `Object.prototype.toString` 访问。
@@unscopables	`"Symbol.unscopables"`	一个对象值属性，其自身的和继承的属性会被相关对象的 `with` 环境绑定所排除。

6.1.6Number 类型

准确地说，数值类型拥有 18437736874454810627（即，2⁶⁴-2⁵³+3）个值，表示为 IEEE-754-2008 格式 64 位双精度数值（IEEE 标准的二进制浮点数算术中描述了它）；除了 IEEE 标准中的 9007199254740990（即，2⁵³-2）个明显的“非数字 ”值，在 ES 中，它们被表示为一个单独的特殊值：NaN（请注意，NaN 值由程序表达式 NaN 产生。）。在某些实现中，外部代码也许有能力探测出众多非数字值之间的不同，但此类行为依赖于具体实现；对于 ES 代码而言，NaN 值相互之间无法区别。

Note

在一个数值被存入后，在 ArrayBuffer（见24.1）或 SharedArrayBuffer（见 24.2）中可能观察到的位模式，不一定与 ES 实现使用的那个数值的内部表示相同。

还有另外两个特殊值，称为正无穷和负无穷。为简洁起见，在以说明为目的时，用符号 +∞ 和 -∞ 分别代表它们。（请注意，这两个无限数值由程序表达式 +Infinity（简作 Infinity）和 -Infinity 产生。）

剩下的 18437736874454810624（即，2⁶⁴-2⁵³）个值被称为有限数值。其中的一半是正数，另一半是负数，对于每个有限的正数而言，都有一个与之对应的、相同规模的负数。

请注意，还有一个正零和一个负零。为简洁起见，类似地，在以说明为目的时，分别用用符号 +0 和 -0 代表这些值。（请注意，这两个数字零由程序表达式 +0（简作 0）和 -0 产生。）

这 18437736874454810622（即，2⁶⁴-2⁵³-2）个有限非零值分为两种：

其中 18428729675200069632（即，2⁶⁴-2⁵⁴）个是常规值，形如

s \times m \times 2 e

这里的 s 是 +1 或 -1，m 是一个小于 2⁵³ 但不小于 2⁵² 的正整数，e 是一个闭区间 -1074 到 971 中的整数。

剩下的 9007199254740990 (that is, 2⁵³-2) 个数值是非正规的，形如：

s \times m \times 2 e

这里的 s 是 +1 或 -1，m 是一个小于 2⁵² 的正整数，e 是 -1074。

请注意，所有规模不超过 2⁵³ 的正整数和负整数都可被数值类型表示（不过，整数 0 有两个呈现形式，+0 和 -0）。

如果一个有限数的数值非零，且用来表达它（上文两种形式之一）的整数 m 是奇数时，则该数值有奇数标记（odd significand）。否则，它有偶数标记（even significand）。

在本规范中，当 x 表示一个精确的非零实数数学量（甚至可以是无理数，比如 π）时，短语 “the Number 值 for x” 的意思是，以下面的方式选择一个数字值：把数值类型中不包括 -0 和两个被加入在数值类型中但不可呈现的值，即 2¹⁰²⁴（即 +1 × 2⁵³ × 2⁹⁷¹）和 -2¹⁰²⁴ （即 -1 × 2⁵³ × 2⁹⁷¹）的其他数值看做所有有限值的集合。选择此集合中一个最接近 x 的值，若集合中的两值近似相等，那么选择有偶数标记的那个；为此，2¹⁰²⁴ 和 -2¹⁰²⁴ 这两个额外的值被认为有偶数标记。最后，若选择 2¹⁰²⁴，用 +∞ 替换它；若选择 -2¹⁰²⁴ ，用 -∞ 替换它；若选择 +0，有且只有 x 小于零时，用 -0 替换它；其它任何被选取的值都不用改变。结果就是 x 的数字值。（此过程正是 IEEE-754-2008 "round to nearest, ties to even" 模式对应的行为。）

某些 ES 运算符仅处理闭区间 -2³¹ 到 2³¹-1 的整数，或闭区间 0 到 2¹⁶-1。这些运算符接受任何数值类型的值，不过，数值首先被转换为预期的整数值中的一个。参见条款 7.1 中介绍的数值转换操作。

6.1.7Object 类型

对象逻辑上是属性的集合，每一个属性属于数据属性或访问器属性的其中一种：

数据属性把一个属性的值与一个ES 语言值和一套 Boolean 属性关联起来。
访问器属性把一个属性的值与一到两个访问器函数和一套 Boolean 属性关联起来。访问器函数用来储存或检索一个和属性相关联的ES 语言值。

属性可以使用键值来标识。一个属性的键值是一个 ES String 值或 Symbol 值。所有的 String 和 Symbol 值，包括空字符串，都是有效的属性键。属性名是键值为 String 值的属性键。

整数索引是一个值为数值型字符串 (见 7.1.16) 的属性键，它的数值是 +0 或一个小于 2⁵³-1 的正整数。数组索引是一个整数索引，它的数值 i 在范围 +0 ≤ i < 2³²-1 内。

属性键可以用来访问属性和它的值。对于属性而言，存在两种访问类型：get 和 set，分别对应值的检索和值的分配。能通过 get 或 set 访问的属性包括自身属性（该对象的自身部分）和通过一个属性继承关系由另一个关联对象提供的继承属性。继承属性可以是关联对象的自身属性或关联对象的继承属性。对象的每个自身属性都必须有一个不同于该对象的其它自身属性的键值。

所有的对象，逻辑上都是属性的集合，但存在几种对象形式，它们在访问和操作其属性时，语义有所不同。普通对象是大多数普遍对象的形式，其拥有默认对象的语义。外来对象是其属性的语义与默认语义存在不同的任何形式的对象。

6.1.7.1属性特性

本规范中的特性用来定义和解释对象属性的状态。一个数据属性把一个属性键的值和特性（见表 2）相关联起来。

表 2: 数据属性的特性

特性名	值域	描述
[[Value]]	任何 ES 语言类型	可以被 get 属性访问检索的值。
[[Writable]]	Boolean	如果为 false，则任何尝试使用 [[Set]] 去更改该属性的[[Value]] 特性的 ES 代码都会失败。
[[Enumerable]]	Boolean	如果为 true，则该属性可以被 for-in 枚举 (见 13.7.5)。否则，该属性是不可枚举的。
[[Configurable]]	Boolean	如果为 false，则任何尝试删除该属性，或将该属性更改为一个访问器属性，或更改它的特性（除了 [[Value]]，或将 [[Writable]] 设置为 false）都会失败。

访问器属性将一个键值与表 3 中所列的特性相关联：

Table 3: 特性 of an 访问器属性

特性名	值域	描述
[[Get]]	Object \| Undefined	如果该值是一个对象，那么它必须是一个函数对象。每当一个 get 属性访问被执行时，该函数的 [[Call]] 内部方法 (表 6) 就会以携带有一个空参数列表的形式所调用，以检索该属性值。
[[Set]]	Object \| Undefined	如果该值是一个对象，那么它必须是一个函数对象。每当一个 set 属性访问被执行时，该函数的 [[Call]] 内部方法 (表 6) 就会以携带有一个参数列表（只包含一个分配值作为其唯一值）的形式被调用。该属性的 [[Set]] 内部方法的效果或许，但不是必须的，对这个，由后续的属性的 [[Get]] 内部方法调用所返回的值，有影响。
[[Enumerable]]	Boolean	如果为 true，则该属性可以被 for-in 枚举 (见 13.7.5)。否则，该属性是不可枚举的。
[[Configurable]]	Boolean	如果为 false，则任何尝试删除该属性，或将该属性更改为一个数据属性，或更改它的特性都会失败。

如果一个属性特性的初始值并没有被本规范显式地指定，那么可以使用表 4 中定义的默认值。

表 4: 默认特性值

特性名	默认值
[[Value]]	undefined
[[Get]]	undefined
[[Set]]	undefined
[[Writable]]	false
[[Enumerable]]	false
[[Configurable]]	false

6.1.7.2对象内部方法和内部属性

在 ES 中，对象实际的语义是通过叫内部方法的算法来指定的。在 ES 引擎中，每一个对象都和定义了它运行时行为的一套内部方法相关联。这些内部方法并不是 ES 语言的一部分，它们是仅以说明为目的，被定义在本规范中。但是，在 ES 实现内的每一个对象的行为都必须表现出仿佛它是被这里的内部方法所指定的一样。实现的具体方式是由 ES 实现决定的。

内部方法的名字是多形态的，这意味着一个常见的内部方法被调用时，不同的对象值可能会呈现出不同的算法。一个被内部方法调用的实际对象是调用的“目标”。如果，在运行时，一个算法的实现尝试去使用一个对象本身不支持的内部方法时，那么一个 TypeError 异常会被抛出。

内部属性响应与之关联的对象的内部状态并常常被使用于 ES 规范算法中。内部属性并不是对象的属性，而且它们不能被继承。根据指定的内部属性规范，对象的状态可能由的 ES 语言类型值或 ES 规范类型的值构成。除非显式指定，要不然内部属性会在对象被创建的过程中作为对象的一部分被分配，而不能被动态的添加给一个对象。除非显式指定，内部属性的初始值是 undefined。在本规范中，不同的算法都会创建出带内部属性的对象。然而，ES 语言并不直接提供一种将内部属性和一个对象相关联的方法。

在本规范中，内部方法和内部属性的名字会被闭合的双方括号 [[ ]] 包裹。

表 5 总结了在本规范中能够被应用于 ES 代码创建和操作的对象所使用的所有必须的基本内部方法。每一个对象都必须存在所有基本内部方法的算法。但是，对于这些内部方法来说，所有对象并没有必要使用相同的算法。

表 5 或其它类似表中的 “Signature” 列描述了每个内部方法的调用模式。这个调用模式总是包含一个描述性的用大括号包裹的参数名列表。如果一个参数的名字与一个 ES 类型名字相似，那么这个参数名描述了参数值的必要的类型。如果一个内部方法显示地返回了一个值，它的参数列表后面会有一符号 “→” 和一个返回值的类型名。被用在 signatures 中的类型名可以参考条款 6 augmented by the following additional names。“any” 表示值可以是任何 ES 语言类型。一个内部方法隐式地返回一个完成记录。除了它的参数外，一个内部方法总是访问方法调用的目标对象。

表 5: 必须的内部方法

内部方法	Signature	Description
[[GetPrototypeOf]]	( ) → Object \| Null	确定为这个对象提供可继承属性的是哪个对象。null 值表明这里没有可继承的属性。
[[SetPrototypeOf]]	(Object \| Null) → Boolean	将这个对象与另一个提供可继承属性的对象相关联。如果传递一个 null 参数，则表示这里没有可继承的属性。返回值为 true 则表明这个操作被成功完成，返回值为 false 则表明操作失败。
[IsExtensible]]	( ) → Boolean	确定是否可以给这个对象添加额外的属性。
[[PreventExtensions]]	( ) → Boolean	控制一个新属性是否可以被添加到该对象。操作成功则返回 true，操作失败则返回 false。
[[GetOwnProperty]]	(`propertyKey`) → Undefined \| 属性描述符	返回该对象的自身属性（如果存在，则键是 `propertyKey` ，如果不存在则键是 undefined）的属性描述符。
[[DefineOwnProperty]]	(`propertyKey`, `PropertyDescriptor`) → Boolean	创建或更改自身属性（键是 `propertyKey` ，拥有属性描述符里描述的状态），如果属性被创建或更新成功则返回 true ，否则返回 false 。
[[HasProperty]]	(`propertyKey`) → Boolean	返回一个布尔值，表明该对象是否已经存在一个自身或者继承来的属性（键是 `propertyKey`）。
[[Get]]	(`propertyKey`, `Receiver`) → any	返回该对象中属性（键是 `propertyKey`）的值。如果任何 ES 代码必须被执行去检索这个属性值，那么当在计算代码时 `Receiver` 会被用作 this 值。
[[Set]]	(`propertyKey`, `value`, `Receiver`) → Boolean	设置该对象中属性（键是 `propertyKey`）为某个值。如果任何 ES 代码必须被执行去设置这个属性值，那么当在计算代码时 `Receiver` 会被用作 this 值。如果属性值被成功设置则返回 true ，否则 false 。
[[Delete]]	(`propertyKey`) → Boolean	从该对象中移除这个自身属性（键是 `propertyKey`）。如果属性被成功删除或不存在则返回 true ，否则 false 。
[[OwnPropertyKeys]]	( ) → List of propertyKey	返回一个的一个列表（元素是这个对象中所有的自身属性）。

表 6 总结了额外的一些可以被作为函数调用的对象所支持的必须内部方法。一个函数对象是一个可以支持 [[Call]] 内部方法的对象。一个构造器（也可以看做一个构造器函数）是一个可以支持 [[Construct]] 内部方法的函数对象。

表 6: Function 对象额外的必须的内部方法

内部方法	Signature	Description
[[Call]]	(any, a List of any) → any	运行与此对象关联的代码。通过函数调用表达式调用。这个内部方法的参数是一个 this 值和一个列表（由一个函数调用表达式传来的参数组成）。实现了这个内部方法的对象是可调用的。
[[Construct]]	(a List of any, Object) → Object	通过 `new` 或者 `super` 运算符调用，创建一个对象。该内部方法的第一个参数是一个列表（包含了操作符的参数）。第二个参数是一个 `new` 对象操作符被首次应用的对象。实现了这个内部方法的对象叫做构造器。一个函数对象不一定是一个构造器，但一个非构造器的函数对象是没有 [[Construct]] 内部方法的。

对于普通对象和标准外来对象，必须内部方法的语义在条款 9 中被指定。如果一个外来对象的一个内部方法的任何规定的使用不被一个实现所支持，那么对这个用法的任何尝试，都会抛出一个 TypeError 异常。

6.1.7.3必须内部方法的不变量

一个 ES 引擎的对象的内部方法必须遵循下面指定的不变量的列表。在本规范中，普通 ES 对象和所有的标准外来对象会坚持这些不变量。ES Proxy 对象会通过运行时检查的方式来维持这些不变量 maintain these 不变量 by means of 运行时检查 on the result of traps invoked on the object.

由外来对象提供的实现也必须坚持这些不变量。违背这些不变量会导致 ES 代码有不可预测的行为和产生安全问题。然而，违背这些不变量不会被一个实现的内存安全所认可。

实现不允许这些不变量被任何的方式所规避，例如，通过提供可代替的接口，其在没有强制使用这些不变量的情况下就实现了必须内部方法的功能，这是不被允许的。

Definitions:

一个内部方法的 target 是被这个内部方法所调用的对象。
如果观察到它的内部方法 [[IsExtensible]] 返回 false 或内部方法 [[PreventExtensions]] 返回 true，那么这个 target 是不可扩展的 。
一个不存在的属性是指，作为一个不可扩展目标的自身属性时，它是不存在的。
对 SameValue 值的所有引用是和 SameValue 算法中的定义保持一致的。

[[GetPrototypeOf]] ( )

返回值的类型必须是 Object 或者 Null。
如果 target 是不可扩展的和 [[GetPrototypeOf]] 返回的值是 v，那么将来任何对 [[GetPrototypeOf]] 的调用也应该返回 v 的 SameValue。

Note 1

一个对象原型链的长度应该是有限的（即，从任何一个对象开始，递归地对 [[GetPrototypeOf]] 方法的结果应用 [[GetPrototypeOf]] 方法，最终会指向一个值 null）。然而，如果这个原型链包含了没有使用普通对象的 [[GetPrototypeOf]] 定义的外来对象，那么，作为一个对象级别的不变量来说，这种需求不是强制的。这种情况下，当访问对象属性时，一个环形的原型链可能导致无限循环。

[[SetPrototypeOf]] (`V`)

返回值的类型应该是 Boolean。
如果一个目标是不可扩展的，那么 [[SetPrototypeOf]] 必须返回 false，除非 V 是一个作为目标的可观察的 [[GetPrototypeOf]] 的值 SameValue。

[[IsExtensible]] ( )

返回值的类型必须是 Boolean.
如果 [[IsExtensible]] 符号 false，那么，所有对目标上的 [[IsExtensible]] 的未来调用都必须返回 false。

[[PreventExtensions]] ( )

返回值的类型必须是 Boolean.
如果 [[PreventExtensions]] 返回 true，那么，使用对目标上的 [[IsExtensible]] 的未来调用都必须返回 false，且该目标现在被认为是不可扩展的。

[[GetOwnProperty]] (`P`)

返回值的类型必须是属性描述符或 Undefined。
如果返回值的类型是属性描述符，那么返回值必须是一个完成的属性描述符 (见 6.2.5.6)。
如果一个属性 P 被描述为一个携带有 Desc.[[Value]] 值为 v，以及 Desc.[[Writable]] 和 Desc.[[Configurable]] 值皆为 false 的数据属性，那么 the SameValue must be returned for the Desc.[[Value]] 特性 of the property on all future calls to [[GetOwnProperty]] ( P ).
If P's 特性 other than [[Writable]] may change over time or if the property might disappear, then P's [[Configurable]] 特性 must be true.
If the [[Writable]] 特性 may change from false to true, then the [[Configurable]] 特性 must be true.
If the target is non-extensible and P is non-existent, then all future calls to [[GetOwnProperty]] (P) on the target must describe P as non-existent (i.e. [[GetOwnProperty]] (P) must return undefined).

Note 2

As a consequence of the third invariant, if a property is described as a 数据属性 and it may return different values over time, then either or both of the Desc.[[Writable]] and Desc.[[Configurable]] 特性 must be true even if no mechanism to change the value is exposed via the other 内部方法.

[[DefineOwnProperty]] (`P`, `Desc`)

返回值的类型必须是 Boolean.
[[DefineOwnProperty]] 必须返回 false if P has previously been observed as a non-configurable 自身属性 of the target, unless either:
1. P is a non-configurable writable own 数据属性. A non-configurable writable 数据属性 can be changed into a non-configurable non-writable 数据属性.
2. All 特性 in Desc are the SameValue as P's 特性.
[[DefineOwnProperty]] (P, Desc) 必须返回 false if target is non-extensible and P is a non-existent 自身属性. That is, a non-extensible target object cannot be extended with new properties.

[[HasProperty]] ( `P` )

返回值的类型必须是 Boolean.
If P was previously observed as a non-configurable data or accessor 自身属性 of the target, [[HasProperty]] must return true.

[[Get]] (`P`, `Receiver`)

If P was previously observed as a non-configurable, non-writable own 数据属性 of the target with value v, then [[Get]] must return the SameValue.
If P was previously observed as a non-configurable own 访问器属性 of the target whose [[Get]] 特性 is undefined, the [[Get]] operation must return undefined.

[[Set]] ( `P`, `V`, `Receiver`)

返回值的类型必须是 Boolean.
If P was previously observed as a non-configurable, non-writable own 数据属性 of the target, then [[Set]] 必须返回 false unless V is the SameValue as P's [[Value]] 特性.
If P was previously observed as a non-configurable own 访问器属性 of the target whose [[Set]] 特性 is undefined, the [[Set]] operation 必须返回 false.

[[Delete]] ( `P` )

返回值的类型必须是 Boolean.
If P was previously observed to be a non-configurable own data or 访问器属性 of the target, [[Delete]] 必须返回 false.

[[OwnPropertyKeys]] ( )

The 返回值 must be a List.
The returned list must not contain any duplicate entries.
The Type of each element of the returned List is either String or Symbol.
The returned List must contain at least the keys of all non-configurable 自身属性 that have previously been observed.
If the object is non-extensible, the returned List must contain only the keys of all 自身属性 of the object that are observable using [[GetOwnProperty]].

[[Construct]] ( )

返回值的类型必须是 Object.

6.1.7.4众所周知的内部对象

众所周知的内部对象是指，在本规范中被显式地引用的内置对象，通常会有一个 realm-specific 标志。除非另有说明，否则每个内部对象实际对应于一套相似对象的集合，one per realm.

在本规范中，一个引用，例如 %name%，意味着该内部对象与当前的 realm 相关联, corresponding to the name. Determination of the current realm and its intrinsics is described in 8.3. 众所周知的内部对象见表 7。

表 7: 众所周知的内部对象

内部对象名称	全局名称	ES 语言关联
%Array%	`Array`	`Array` 构造器 (22.1.1)
%ArrayBuffer%	`ArrayBuffer`	`ArrayBuffer` 构造器 (24.1.2)
%ArrayBufferPrototype%	`ArrayBuffer.prototype`	%ArrayBuffer% 数据属性 `prototype` 的初始值。
%ArrayIteratorPrototype%		Array 迭代器对象 (22.1.5) 的原型
%ArrayPrototype%	`Array.prototype`	%Array% (22.1.3) 数据属性 `prototype` 的初始值。
%ArrayProto_entries%	`Array.prototype.entries`	%ArrayPrototype% (22.1.3.4) 数据属性 `entries` 的初始值。
%ArrayProto_forEach%	`Array.prototype.forEach`	%ArrayPrototype% (22.1.3.10) 数据属性 `forEach` 的初始值。
%ArrayProto_keys%	`Array.prototype.keys`	%ArrayPrototype% (22.1.3.14) 数据属性 `keys` 的初始值。
%ArrayProto_values%	`Array.prototype.values`	%ArrayPrototype% (22.1.3.30) 数据属性 `values` 的初始值。
%AsyncFromSyncIteratorPrototype%		async-from-sync 迭代器对象 (25.1.4) 的原型。
%AsyncFunction%		async 函数对象 (25.7.1) 的构造器
%AsyncFunctionPrototype%		The 初始值 of the `prototype` 数据属性 of %AsyncFunction%
%AsyncGenerator%		%AsyncGeneratorFunction% 数据属性 `prototype` 的初始值。
%AsyncGeneratorFunction%		async 迭代器对象 (25.3.1) 的构造器
%AsyncGeneratorPrototype%		%AsyncGenerator% `prototype` 属性的初始值。
%AsyncIteratorPrototype%		所有标准内置 async 迭代器对象间接继承的对象。
%Atomics%	`Atomics`	`Atomics` 对象 (24.4)
%Boolean%	`Boolean`	`Boolean` 构造器 (19.3.1)
%BooleanPrototype%	`Boolean.prototype`	%Boolean% (19.3.3) 数据属性 `prototype` 的初始值。
%DataView%	`DataView`	`DataView` 构造器 (24.3.2)
%DataViewPrototype%	`DataView.prototype`	%DataView% 数据属性 `prototype` 的初始值。
%Date%	`Date`	`Date` 构造器 (20.3.2)
%DatePrototype%	`Date.prototype`	%Date% 数据属性 `prototype` 的初始值。
%decodeURI%	`decodeURI`	`decodeURI` 函数 (18.2.6.2)
%decodeURIComponent%	`decodeURIComponent`	`decodeURIComponent` 函数 (18.2.6.3)
%encodeURI%	`encodeURI`	`encodeURI` 函数 (18.2.6.4)
%encodeURIComponent%	`encodeURIComponent`	`encodeURIComponent` 函数 (18.2.6.5)
%Error%	`Error`	`Error` 构造器 (19.5.1)
%ErrorPrototype%	`Error.prototype`	%Error% 数据属性 `prototype` 的初始值。
%eval%	`eval`	`eval` 函数 (18.2.1)
%EvalError%	`EvalError`	`EvalError` 构造器 (19.5.5.1)
%EvalErrorPrototype%	`EvalError.prototype`	%EvalError% 数据属性 `prototype` 的初始值。
%Float32Array%	`Float32Array`	`Float32Array` 构造器 (22.2)
%Float32ArrayPrototype%	`Float32Array.prototype`	%Float32Array% 数据属性 `prototype` 的初始值。
%Float64Array%	`Float64Array`	`Float64Array` 构造器 (22.2)
%Float64ArrayPrototype%	`Float64Array.prototype`	%Float64Array% 数据属性 `prototype` 的初始值。
%Function%	`Function`	`Function` 构造器 (19.2.1)
%FunctionPrototype%	`Function.prototype`	%Function% 数据属性 `prototype` 的初始值。
%Generator%		%GeneratorFunction% 数据属性 `prototype` 的初始值。
%GeneratorFunction%		生成器对象 (25.2.1) 的构造器
%GeneratorPrototype%		%Generator% 数据属性 `prototype` 的初始值。
%Int8Array%	`Int8Array`	The `Int8Array` 构造器 (22.2)
%Int8ArrayPrototype%	`Int8Array.prototype`	%Int8Array% 数据属性 `prototype` 的初始值。
%Int16Array%	`Int16Array`	`Int16Array` 构造器 (22.2)
%Int16ArrayPrototype%	`Int16Array.prototype`	%Int16Array% 数据属性 `prototype` 的初始值。
%Int32Array%	`Int32Array`	`Int32Array` 构造器 (22.2)
%Int32ArrayPrototype%	`Int32Array.prototype`	%Int32Array% 数据属性 `prototype` 的初始值。
%isFinite%	`isFinite`	`isFinite` 函数 (18.2.2)
%isNaN%	`isNaN`	`isNaN` 函数 (18.2.3)
%IteratorPrototype%		所有标准内置迭代器对象间接继承的对象
%JSON%	`JSON`	`JSON` 对象 (24.5)
%JSONParse%	`JSON.parse`	%JSON% 数据属性 `parse` 的初始值。
%Map%	`Map`	`ap` 构造器 (23.1.1)
%MapIteratorPrototype%		Map 迭代器对象 (23.1.5) 的原型
%MapPrototype%	`Map.prototype`	%Map% 数据属性 `prototype` 的初始值。
%Math%	`Math`	`Math` 对象 (20.2)
%Number%	`Number`	`Number` 构造器 (20.1.1)
%NumberPrototype%	`Number.prototype`	%Number% 数据属性 `prototype` 的初始值。
%Object%	`Object`	`Object` 构造器 (19.1.1)
%ObjectPrototype%	`Object.prototype`	%Object% (19.1.3) 数据属性 `prototype` 的初始值。
%ObjProto_toString%	`Object.prototype.toString`	%ObjectPrototype% (19.1.3.6) 数据属性 `toString` 的初始值。
%ObjProto_valueOf%	`Object.prototype.valueOf`	%ObjectPrototype% (19.1.3.7) 数据属性 `valueOf` 的初始值。
%parseFloat%	`parseFloat`	`parseFloat` 函数 (18.2.4)
%parseInt%	`parseInt`	`parseInt` 函数 (18.2.5)
%Promise%	`Promise`	`Promise` 构造器 (25.6.3)
%PromisePrototype%	`Promise.prototype`	`prototype` 数据属性 of %Promise% 数据属性 `prototype` 的初始值。
%PromiseProto_then%	`Promise.prototype.then`	%PromisePrototype% (25.6.5.4) 数据属性 `then` 的初始值。
%Promise_all%	`Promise.all`	%Promise% (25.6.4.1) 数据属性 `all` 的初始值。
%Promise_reject%	`Promise.reject`	%Promise% (25.6.4.4) 数据属性 `reject` 的初始值。
%Promise_resolve%	`Promise.resolve`	%Promise% (25.6.4.5) 数据属性 `resolve` 的初始值。
%Proxy%	`Proxy`	`Proxy` 构造器 (26.2.1)
%RangeError%	`RangeError`	`RangeError` 构造器 (19.5.5.2)
%RangeErrorPrototype%	`RangeError.prototype`	%RangeError% 数据属性 `prototype` 的初始值。
%ReferenceError%	`ReferenceError`	`ReferenceError` 构造器 (19.5.5.3)
%ReferenceErrorPrototype%	`ReferenceError.prototype`	%ReferenceError% 数据属性 `prototype` 的初始值。
%Reflect%	`Reflect`	`Reflect` 对象 (26.1)
%RegExp%	`RegExp`	`RegExp` 构造器 (21.2.3)
%RegExpPrototype%	`RegExp.prototype`	%RegExp% 数据属性 `prototype` 的初始值。
%Set%	`Set`	`et` 构造器 (23.2.1)
%SetIteratorPrototype%		Set 迭代器对象 (23.2.5) 的原型
%SetPrototype%	`Set.prototype`	%Set% 数据属性 `prototype` 的初始值。
%SharedArrayBuffer%	`SharedArrayBuffer`	`SharedArrayBuffer` 构造器 (24.2.2)
%SharedArrayBufferPrototype%	`SharedArrayBuffer.prototype`	%SharedArrayBuffer% 数据属性 `prototype` 的初始值。
%String%	`String`	`String` 构造器 (21.1.1)
%StringIteratorPrototype%		String 迭代器对象 (21.1.5) 的原型
%StringPrototype%	`String.prototype`	%String% 数据属性 `prototype` 的初始值。
%Symbol%	`Symbol`	`Symbol` 构造器 (19.4.1)
%SymbolPrototype%	`Symbol.prototype`	%Symbol% (19.4.3) 数据属性 `prototype` 的初始值。
%SyntaxError%	`SyntaxError`	`SyntaxError` 构造器 (19.5.5.4)
%SyntaxErrorPrototype%	`SyntaxError.prototype`	%SyntaxError% 数据属性 `prototype` 的初始值。
%ThrowTypeError%		一个无条件抛出 %TypeError% 的一个新实例的函数对象
%TypedArray%		所有 typed Array 构造器 (22.2.1) 的父类
%TypedArrayPrototype%		%TypedArray% 数据属性 `prototype` 的初始值。
%TypeError%	`TypeError`	`TypeError` 构造器 (19.5.5.5)
%TypeErrorPrototype%	`TypeError.prototype`	%TypeError% 数据属性 `prototype` 的初始值。
%Uint8Array%	`Uint8Array`	`Uint8Array` 构造器 (22.2)
%Uint8ArrayPrototype%	`Uint8Array.prototype`	%Uint8Array% 数据属性 `prototype` 的初始值。
%Uint8ClampedArray%	`Uint8ClampedArray`	`Uint8ClampedArray` 构造器 (22.2)
%Uint8ClampedArrayPrototype%	`Uint8ClampedArray.prototype`	%Uint8ClampedArray% 数据属性 `prototype` 的初始值。
%Uint16Array%	`Uint16Array`	`Uint16Array` 构造器 (22.2)
%Uint16ArrayPrototype%	`Uint16Array.prototype`	%Uint16Array% 数据属性 `prototype` 的初始值。
%Uint32Array%	`Uint32Array`	`Uint32Array` 构造器 (22.2)
%Uint32ArrayPrototype%	`Uint32Array.prototype`	%Uint32Array% 数据属性 `prototype` 的初始值。
%URIError%	`URIError`	`URIError` 构造器 (19.5.5.6)
%URIErrorPrototype%	`URIError.prototype`	%URIError% 数据属性 `prototype` 的初始值。
%WeakMap%	`WeakMap`	`WeakMap` 构造器 (23.3.1)
%WeakMapPrototype%	`WeakMap.prototype`	%WeakMap% 数据属性 `prototype` 的初始值。
%WeakSet%	`WeakSet`	`WeakSet` 构造器 (23.4.1)
%WeakSetPrototype%	`WeakSet.prototype`	%WeakSet% 数据属性 `prototype` 的初始值。

6.2ES 规范类型

规范类型响应 meta-values，meta-values 用在算法中，目的是为了描述 ES 语言构建块和 ES 语言类型。规范类型包括 Reference（引用）, List（列表）, Completion（完成）, 属性描述符（属性描述符）, 词法环境（词法环境）, 环境记录（环境记录）, 和数据块（数据块）. 规范类型的值是 specification artefacts，该值并没有必要去响应在 ES 实现中的任何特别的实体。规范类型的值可以用来描述 ES 表达式求值过程中的中间结果，但是这样的值不能存储在对象的属性或 ES 语言变量的值中。

6.2.1列表规范类型和记录规范类型

列表类型用来说明在 new 表达式、函数调用和其他需要一个简单有序的值列表的算法中参数列表 (see 12.3.6) 的计算。列表类型的值是包含单个值的简单有序的列表元素的序列，这些序列可以是任意长度。列表内的元素可以被基于 0 的索引随机访问。为了方便起见，一个类似数组的语法可以用来访问列表的元素。例如，arguments[2] 用来表示列表参数的第三个元素。

在本规范中，为了方便起见，可以用字面量语法来表达一个新列表的值。例如， « 1, 2 » 定义了一个有两个元素的列表值，其中每个元素都会被初始化为一个特别的值。一个新的空列表可以用 « » 来表示。

在本规范中，记录类型用来描述算法内的数据聚合。一个记录类型的值由一个或多个被命名的域组成。每个域的值是 ES 值或是一个和记录类型相关联的名字的抽象值。域的名字总是被双方括号包裹，例如 [[Value]]。

在本规范总，为了方便起见，对象字面量的语法可以被用来表达一个记录的值。例如，{[[Field1]]: 42, [[Field2]]: false, [[Field3]]: empty} 定义了一个拥有三个域的记录值，每个与的值都会被初始化为一个特定的值。域名的顺序是无关紧要的。任何没有显式列出来的域都可以认为是不需要的。

在规范文本和算法中，点标记被用来参考一个记录值的特殊字段。例如，如果 R 是上一个段落中的一个记录，那么 R.[[Field2]] 就是 “the field of R named [[Field2]]” 的简写。

Schema for commonly used Record field combinations may be named, and that name may be used as a prefix to a literal 记录值 to identify the specific kind of aggregations that is being described. 例如：PropertyDescriptor {[[Value]]: 42, [[Writable]]: false, [[Configurable]]: true}.

6.2.2集合规范类型和关系规范类型

The Set type is used to explain a collection of unordered elements for use in the 内存模型. Values of the Set type are simple collections of elements, where no element appears more than once. Elements may be added to and removed from Sets. Sets may be unioned, intersected, or subtracted from each other.

The Relation type is used to explain constraints on Sets. Values of the 关系类型 are Sets of ordered pairs of values from its value domain. 例如, a Relation on events is a set of ordered pairs of events. For a Relation R and two values a and b in the value domain of R, a R b is shorthand for saying the ordered pair (a, b) is a member of R. A Relation is least with respect to some conditions when it is the smallest Relation that satisfies those conditions.

A strict partial order is a 关系值 R that satisfies the following.

For all a, b, and c in R's domain:
- It is not the case that a R a, and
- If a R b and b R c, then a R c.

Note 1

The two properties above are called, in order, irreflexivity and transitivity.

A strict total order is a 关系值 R that satisfies the following.

For all a, b, and c in R's domain:
- a is identical to b or a R b or b R a, and
- It is not the case that a R a, and
- If a R b and b R c, then a R c.

Note 2

The three properties above are called, in order, totality, irreflexivity, and transitivity.

6.2.3完成记录规范类型

The 完成类型 is a Record used to explain the runtime propagation of values and control flow 例如 the behaviour of statements (break, continue, return and throw) that perform nonlocal transfers of control.

Values of the 完成类型 are Record values whose fields are defined as by Table 8. Such values are referred to as 完成记录s.

Table 8: 完成记录 Fields

字段名	Value	Meaning
[[Type]]	One of normal, break, continue, return, or throw	The type of completion that occurred.
[[Value]]	any ES 语言值 or empty	The value that was produced.
[[Target]]	any ES string or empty	The target label for directed control transfers.

The term “abrupt completion” refers to any completion with a [[Type]] value other than normal.

6.2.3.1Await

算法步骤 that say

Let completion be Await(promise).

等同于:

Let asyncContext be the 运行时执行上下文.
Let promiseCapability be ! NewPromiseCapability(%Promise%).
Perform ! Call(promiseCapability.[[Resolve]], undefined, « promise »).
Let stepsFulfilled be the 算法步骤 defined in Await Fulfilled Functions.
Let onFulfilled be CreateBuiltinFunction(stepsFulfilled, « [[AsyncContext]] »).
Set onFulfilled.[[AsyncContext]] to asyncContext.
Let stepsRejected be the 算法步骤 defined in Await Rejected Functions.
Let onRejected be CreateBuiltinFunction(stepsRejected, « [[AsyncContext]] »).
Set onRejected.[[AsyncContext]] to asyncContext.
Let throwawayCapability be ! NewPromiseCapability(%Promise%).
Set throwawayCapability.[[Promise]].[[PromiseIsHandled]] to true.
Perform ! PerformPromiseThen(promiseCapability.[[Promise]], onFulfilled, onRejected, throwawayCapability).
Remove asyncContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
Set the code 估值 state of asyncContext such that when 估值 is resumed with a Completion completion, the following steps of the 算法 that invoked Await will be performed, with completion available.

where all variables in the above steps, with the 异常 of completion, are ephemeral and visible only in the steps pertaining to Await.

Note

Await can be combined with the ? and ! prefixes, so that 例如

Let value be ? Await(promise).

等同于:

Let value be Await(promise).
ReturnIfAbrupt(value).

6.2.3.1.1Await Fulfilled Functions

An Await fulfilled function is an anonymous 内置函数 that is used as part of the Await specification device to deliver the promise fulfillment value to the caller as a normal completion. Each Await fulfilled function has an [[AsyncContext]] 内部属性.

When an Await fulfilled function F is called with argument value, 执行如下:

Let asyncContext be F.[[AsyncContext]].
Let prevContext be the 运行时执行上下文.
Suspend prevContext.
Push asyncContext onto the 执行上下文堆栈; asyncContext is now the 运行时执行上下文.
Resume the suspended 估值 of asyncContext using NormalCompletion(value) as the result of the operation that suspended it.
Assert: When we reach this step, asyncContext has already been removed from the 执行上下文堆栈 and prevContext is the currently 运行时执行上下文.
Return undefined.

The length property of an Await fulfilled function is 1.

6.2.3.1.2Await Rejected Functions

An Await rejected function is an anonymous 内置函数 that is used as part of the Await specification device to deliver the promise rejection reason to the caller as an abrupt throw completion. Each Await rejected function has an [[AsyncContext]] 内部属性.

When an Await rejected function F is called with argument reason, 执行如下:

Let asyncContext be F.[[AsyncContext]].
Let prevContext be the 运行时执行上下文.
Suspend prevContext.
Push asyncContext onto the 执行上下文堆栈; asyncContext is now the 运行时执行上下文.
Resume the suspended 估值 of asyncContext using Completion{[[Type]]: throw, [[Value]]: reason, [[Target]]: empty} as the result of the operation that suspended it.
Assert: When we reach this step, asyncContext has already been removed from the 执行上下文堆栈 and prevContext is the currently 运行时执行上下文.
Return undefined.

The length property of an Await rejected function is 1.

6.2.3.2NormalCompletion

The 抽象操作 NormalCompletion with a single argument, 例如:

Return NormalCompletion(argument).

Is a shorthand that is defined as follows:

Return Completion{[[Type]]: normal, [[Value]]: argument, [[Target]]: empty}.

6.2.3.3UpdateEmpty ( `completionRecord`, `value` )

The 抽象操作 UpdateEmpty with arguments completionRecord and value 执行如下:

Assert: If completionRecord.[[Type]] is either return or throw, then completionRecord.[[Value]] is not empty.
If completionRecord.[[Value]] is not empty, return Completion(completionRecord).
Return Completion{[[Type]]: completionRecord.[[Type]], [[Value]]: value, [[Target]]: completionRecord.[[Target]] }.

6.2.4引用规范类型

Note

引用类型用来解释 delete、typeof 这样的操作符、分配操作符、super 关键字和其它的一些语言特征。例如，一个分配的左操作会被期待产生一个引用。

一个引用是一个已解析名字或者一个属性绑定。一个引用由三个部分组成：基值组件、引用名组件和一个布尔值的严格引用标志。基值组件是 undefined、Object、Boolean、String、Symbol、Number 的其中一个, 或者是一个环境记录. undefined 的基值组件暗示这个引用不能被解析成一个绑定。引用名组件是一个字符串或一个符号值。

一个用 super 关键字来表达的 Super 引用被用来表示一个名字绑定。一个 Super 引用有一个额外的 this 值组件，和该引用的基值不能是一个环境记录。

在本规范中，以下的抽象操作被用来操作一个引用：

6.2.4.1GetBase ( `V` )

Assert: Type(V) is Reference.
Return the base value component of V.

6.2.4.2GetReferencedName ( `V` )

Assert: Type(V) is Reference.
Return the referenced name component of V.

6.2.4.3IsStrictReference ( `V` )

Assert: Type(V) is Reference.
Return the strict reference flag of V.

6.2.4.4HasPrimitiveBase ( `V` )

Assert: Type(V) is Reference.
If Type(V's base value component) is Boolean, String, Symbol, or Number, return true; otherwise return false.

6.2.4.5IsPropertyReference ( `V` )

Assert: Type(V) is Reference.
If either the base value component of V is an Object or HasPrimitiveBase(V) is true, return true; otherwise return false.

6.2.4.6IsUnresolvableReference ( `V` )

Assert: Type(V) is Reference.
If the base value component of V is undefined, return true; otherwise return false.

6.2.4.7IsSuperReference ( `V` )

Assert: Type(V) is Reference.
If V has a thisValue component, return true; otherwise return false.

6.2.4.8GetValue ( `V` )

ReturnIfAbrupt(V).
If Type(V) is not Reference, return V.
Let base be GetBase(V).
If IsUnresolvableReference(V) is true, 抛出一个 ReferenceError 异常.
If IsPropertyReference(V) is true, then
1. If HasPrimitiveBase(V) is true, then
  1. Assert: In this case, base will never be undefined or null.
  2. Set base to ! ToObject(base).
2. Return ? base.[[Get]](GetReferencedName(V), GetThisValue(V)).
Else base must be an 环境记录,
1. Return ? base.GetBindingValue(GetReferencedName(V), IsStrictReference(V)) (see 8.1.1).

Note

The object that may be created in step 5.a.ii is not accessible outside of the above 抽象操作 and the 普通对象 [[Get]] 内部方法. An 实现 might choose to avoid the actual creation of the object.

6.2.4.9PutValue ( `V`, `W` )

ReturnIfAbrupt(V).
ReturnIfAbrupt(W).
If Type(V) is not Reference, 抛出一个 ReferenceError 异常.
Let base be GetBase(V).
If IsUnresolvableReference(V) is true, then
1. If IsStrictReference(V) is true, then
  1. 抛出一个 ReferenceError 异常.
2. Let globalObj be GetGlobalObject().
3. Return ? Set(globalObj, GetReferencedName(V), W, false).
Else if IsPropertyReference(V) is true, then
1. If HasPrimitiveBase(V) is true, then
  1. Assert: In this case, base will never be undefined or null.
  2. Set base to ! ToObject(base).
2. Let succeeded be ? base.[[Set]](GetReferencedName(V), W, GetThisValue(V)).
3. If succeeded is false and IsStrictReference(V) is true, 抛出一个 TypeError 异常.
4. Return.
Else base must be an 环境记录,
1. Return ? base.SetMutableBinding(GetReferencedName(V), W, IsStrictReference(V)) (see 8.1.1).

Note

The object that may be created in step 6.a.ii is not accessible outside of the above 算法 and the 普通对象 [[Set]] 内部方法. An 实现 might choose to avoid the actual creation of that object.

6.2.4.10GetThisValue ( `V` )

Assert: IsPropertyReference(V) is true.
If IsSuperReference(V) is true, then
1. Return the value of the thisValue component of the reference V.
Return GetBase(V).

6.2.4.11InitializeReferencedBinding ( `V`, `W` )

ReturnIfAbrupt(V).
ReturnIfAbrupt(W).
Assert: Type(V) is Reference.
Assert: IsUnresolvableReference(V) is false.
Let base be GetBase(V).
Assert: base is an 环境记录.
Return base.InitializeBinding(GetReferencedName(V), W).

6.2.5属性描述符规范类型

属性描述符类型用来解释对象属性特性的操作和具体化。属性描述符类型的值是一个记录，该记录的每一个域名是一个特性名，对应的域值符合在 6.1.7.1 中指定的特性值。此外，任何域都可存在或者不存在。在本规范中，被用来标记属性描述符记录的字面量描述的概要（schema）名是 “PropertyDescriptor”。

根据是否存在或使用了某些字段，属性描述符的值可进一步划分为数据属性描述符和访问器属性描述符。一个数据属性描述符里包括叫做 [[Value]] 或 [[Writable]] 的字段。一个访问器属性描述符里包括叫做 [[Get]] 或 [[Set]] 的字段。任何属性描述都可能有名为 [[Enumerable]] 和 [[Configurable]] 的字段。一个属性描述符不能同时是数据属性描述符和访问器属性描述符；但是，它可能二者都不是。一个通用属性描述符是，既不是数据属性描述符也不是访问器属性描述符的属性描述符值。一个完全填充属性描述符是访问器属性描述符或数据属性描述符，并且拥有 Table 2 或 Table 3 里定义的所有属性特性对应的字段。

在本规范中，以下抽象操作被用来操作属性描述符的值：

6.2.5.1IsAccessorDescriptor ( `Desc` )

When the 抽象操作 IsAccessorDescriptor is called with 属性描述符 Desc, 执行如下:

If Desc is undefined, return false.
If both Desc.[[Get]] and Desc.[[Set]] are absent, return false.
Return true.

6.2.5.2IsDataDescriptor ( `Desc` )

When the 抽象操作 IsDataDescriptor is called with 属性描述符 Desc, 执行如下:

If Desc is undefined, return false.
If both Desc.[[Value]] and Desc.[[Writable]] are absent, return false.
Return true.

6.2.5.3IsGenericDescriptor ( `Desc` )

When the 抽象操作 IsGenericDescriptor is called with 属性描述符 Desc, 执行如下:

If Desc is undefined, return false.
If IsAccessorDescriptor(Desc) and IsDataDescriptor(Desc) are both false, return true.
Return false.

6.2.5.4FromPropertyDescriptor ( `Desc` )

When the 抽象操作 FromPropertyDescriptor is called with 属性描述符 Desc, 执行如下:

If Desc is undefined, return undefined.
Let obj be ObjectCreate(%ObjectPrototype%).
Assert: obj is an extensible 普通对象 with no 自身属性.
If Desc has a [[Value]] field, then
1. Perform CreateDataProperty(obj, "value", Desc.[[Value]]).
If Desc has a [[Writable]] field, then
1. Perform CreateDataProperty(obj, "writable", Desc.[[Writable]]).
If Desc has a [[Get]] field, then
1. Perform CreateDataProperty(obj, "get", Desc.[[Get]]).
If Desc has a [[Set]] field, then
1. Perform CreateDataProperty(obj, "set", Desc.[[Set]]).
If Desc has an [[Enumerable]] field, then
1. Perform CreateDataProperty(obj, "enumerable", Desc.[[Enumerable]]).
If Desc has a [[Configurable]] field, then
1. Perform CreateDataProperty(obj, "configurable", Desc.[[Configurable]]).
Assert: All of the above CreateDataProperty operations return true.
Return obj.

6.2.5.5ToPropertyDescriptor ( `Obj` )

When the 抽象操作 ToPropertyDescriptor is called with object Obj, 执行如下:

If Type(Obj) is not Object, 抛出一个 TypeError 异常.
Let desc be a new 属性描述符 that initially has no fields.
Let hasEnumerable be ? HasProperty(Obj, "enumerable").
If hasEnumerable is true, then
1. Let enum be ToBoolean(? Get(Obj, "enumerable")).
2. Set desc.[[Enumerable]] to enum.
Let hasConfigurable be ? HasProperty(Obj, "configurable").
If hasConfigurable is true, then
1. Let conf be ToBoolean(? Get(Obj, "configurable")).
2. Set desc.[[Configurable]] to conf.
Let hasValue be ? HasProperty(Obj, "value").
If hasValue is true, then
1. Let value be ? Get(Obj, "value").
2. Set desc.[[Value]] to value.
Let hasWritable be ? HasProperty(Obj, "writable").
If hasWritable is true, then
1. Let writable be ToBoolean(? Get(Obj, "writable")).
2. Set desc.[[Writable]] to writable.
Let hasGet be ? HasProperty(Obj, "get").
If hasGet is true, then
1. Let getter be ? Get(Obj, "get").
2. If IsCallable(getter) is false and getter is not undefined, 抛出一个 TypeError 异常.
3. Set desc.[[Get]] to getter.
Let hasSet be ? HasProperty(Obj, "set").
If hasSet is true, then
1. Let setter be ? Get(Obj, "set").
2. If IsCallable(setter) is false and setter is not undefined, 抛出一个 TypeError 异常.
3. Set desc.[[Set]] to setter.
If desc.[[Get]] is present or desc.[[Set]] is present, then
1. If desc.[[Value]] is present or desc.[[Writable]] is present, 抛出一个 TypeError 异常.
Return desc.

6.2.5.6CompletePropertyDescriptor ( `Desc` )

When the 抽象操作 CompletePropertyDescriptor is called with 属性描述符 Desc, 执行如下:

Assert: Desc is a 属性描述符.
Let like be Record{[[Value]]: undefined, [[Writable]]: false, [[Get]]: undefined, [[Set]]: undefined, [[Enumerable]]: false, [[Configurable]]: false}.
If IsGenericDescriptor(Desc) is true or IsDataDescriptor(Desc) is true, then
1. If Desc does not have a [[Value]] field, set Desc.[[Value]] to like.[[Value]].
2. If Desc does not have a [[Writable]] field, set Desc.[[Writable]] to like.[[Writable]].
Else,
1. If Desc does not have a [[Get]] field, set Desc.[[Get]] to like.[[Get]].
2. If Desc does not have a [[Set]] field, set Desc.[[Set]] to like.[[Set]].
If Desc does not have an [[Enumerable]] field, set Desc.[[Enumerable]] to like.[[Enumerable]].
If Desc does not have a [[Configurable]] field, set Desc.[[Configurable]] to like.[[Configurable]].
Return Desc.

6.2.6词法环境规范类型和环境记录规范类型

词法环境和环境记录类型用于说明在嵌套的函数或块中的名称解析行为。这些类型和他们的操作定义在 8.1。

6.2.7数据块

The 数据块规范类型 is used to describe a distinct and mutable sequence of byte-sized (8 bit) numeric values. A 数据块 value is created with a fixed number of bytes that each have the 初始值 0.

For notational convenience within this specification, an array-like syntax can be used to access the individual bytes of a 数据块 value. This notation presents a 数据块 value as a 0-origined integer-indexed sequence of bytes. 例如, if db is a 5 byte 数据块 value then db[2] can be used to access its 3^rd byte.

A 数据块 that resides in memory that can be referenced from multiple 代理 concurrently is designated a 共享数据块. A 共享数据块 has an identity (for the purposes of equality testing 共享数据块 values) that is address-free: it is tied not to the virtual addresses the block is mapped to in any process, but to the set of locations in memory that the block represents. Two 数据块 are equal only if the sets of the locations they contain are equal; otherwise, they are not equal and the intersection of the sets of locations they contain is empty. Finally, Shared 数据块 can be distinguished from 数据块.

The 语义 of Shared 数据块 is defined using 共享数据块 events by the 内存模型. 抽象操作 below introduce 共享数据块 events and act as the interface between 估值语义 and the event 语义 of the 内存模型. The events form a candidate execution, on which the 内存模型 acts as a filter. Please consult the 内存模型 for full 语义.

共享数据块 events are modeled by Records, defined in the 内存模型.

The following 抽象操作 are used 在本规范中 to operate upon 数据块 values:

6.2.7.1CreateByteDataBlock ( `size` )

When the 抽象操作 CreateByteDataBlock is called with integer argument size, 执行如下:

Assert: size≥0.
Let db be a new 数据块 value consisting of size bytes. If it is impossible to create such a 数据块, 抛出一个 RangeError 异常.
Set all of the bytes of db to 0.
Return db.

6.2.7.2CreateSharedByteDataBlock( `size` )

When the 抽象操作 CreateSharedByteDataBlock is called with integer argument size, 执行如下:

Assert: size≥0.
Let db be a new 共享数据块 value consisting of size bytes. If it is impossible to create such a 共享数据块, 抛出一个 RangeError 异常.
Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
Let zero be « 0 ».
For each index i of db, do
1. Append WriteSharedMemory{ [[Order]]: "Init", [[NoTear]]: true, [[Block]]: db, [[ByteIndex]]: i, [[ElementSize]]: 1, [[Payload]]: zero } to eventList.
Return db.

6.2.7.3CopyDataBlockBytes ( `toBlock`, `toIndex`, `fromBlock`, `fromIndex`, `count` )

When the 抽象操作 CopyDataBlockBytes is called, 执行如下:

Assert: fromBlock and toBlock are distinct 数据块 or 共享数据块 values.
Assert: fromIndex, toIndex, and count are integer values ≥ 0.
Let fromSize be the number of bytes in fromBlock.
Assert: fromIndex+count ≤ fromSize.
Let toSize be the number of bytes in toBlock.
Assert: toIndex+count ≤ toSize.
Repeat, while count>0
1. If fromBlock is a 共享数据块, then
  1. Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
  2. Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
  3. Let bytes be a List of length 1 that contains a nondeterministically chosen byte value.
  4. NOTE: In implementations, bytes is the result of a non-atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the 内存模型 to describe observable behaviour of hardware with weak consistency.
  5. Let readEvent be ReadSharedMemory{ [[Order]]: "Unordered", [[NoTear]]: true, [[Block]]: fromBlock, [[ByteIndex]]: fromIndex, [[ElementSize]]: 1 }.
  6. Append readEvent to eventList.
  7. Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: bytes } to execution.[[ChosenValues]].
  8. If toBlock is a 共享数据块, then
    1. Append WriteSharedMemory{ [[Order]]: "Unordered", [[NoTear]]: true, [[Block]]: toBlock, [[ByteIndex]]: toIndex, [[ElementSize]]: 1, [[Payload]]: bytes } to eventList.
  9. Else,
    1. Set toBlock[toIndex] to bytes[0].
2. Else,
  1. Assert: toBlock is not a 共享数据块.
  2. Set toBlock[toIndex] to fromBlock[fromIndex].
3. Increment toIndex and fromIndex each by 1.
4. Decrement count by 1.
Return NormalCompletion(empty).

7抽象操作

这些操作并不是 ES 语言的一部分，它们被定义在这里只是为了帮助规范 ES 语言的语义。另外，更多专业化的抽象操作被定义在整个规范中。

7.1 类型转换

在需要的时候，ES 语言会自动的进行隐式类型转换。为了阐明一些构建的语义，定义一套转换抽象操作是很有用的。转换抽象操作是多形态的，它们可以接受任意一个 ES 语言类型的值。但是 ES 的规范类型不能使用这些操作。

7.1.1ToPrimitive ( `input` [ , `PreferredType` ] )

ToPrimitive 抽象操作可以接收一个输入参数和一个可选参数 PreferredType。ToPrimitive 会将转换它的输入参数为一个非对象类型。如果一个对象能够被转换为不止一个原始类型，那么它可以使用可选的暗示参数 PreferredType 来指定它倾向转换的类型。根据以下算法，转换可能发生在：

Assert: input is an ES 语言值.
If Type(input) is Object, then
1. If PreferredType is not present, let hint be "default".
2. Else if PreferredType is hint String, let hint be "string".
3. Else PreferredType is hint Number, let hint be "number".
4. Let exoticToPrim be ? GetMethod(input, @@toPrimitive).
5. If exoticToPrim is not undefined, then
  1. Let result be ? Call(exoticToPrim, input, « hint »).
  2. If Type(result) is not Object, return result.
  3. 抛出一个 TypeError 异常.
6. If hint is "default", set hint to "number".
7. Return ? OrdinaryToPrimitive(input, hint).
Return input.

Note

当 ToPrimitive 在没有暗示就被调用时，那么它默认转换的类型是 Number。定义了一个 @@toPrimitive 方法的对象可能会覆盖此行为，在本规范中，此类对象只有日期对象 (见 20.3.4.45) 和符号对象 (see 19.4.3.4) 会覆盖默认的 ToPrimitive 行为。在没有暗示的情况下，日期对象会转换为字符串。

7.1.1.1OrdinaryToPrimitive ( `O`, `hint` )

当抽象操作 OrdinaryToPrimitive 被以参数 O 和 hint 的形式调用时，以下步骤会被采用：

Assert: Type(O) is Object.
Assert: Type(hint) is String and its value is either "string" or "number".
If hint is "string", then
1. Let methodNames be « "toString", "valueOf" ».
Else,
1. Let methodNames be « "valueOf", "toString" ».
For each name in methodNames in List order, do
1. Let method be ? Get(O, name).
2. If IsCallable(method) is true, then
  1. Let result be ? Call(method, O).
  2. If Type(result) is not Object, return result.
抛出一个 TypeError 异常.

7.1.2ToBoolean ( `argument` )

抽象操作 ToBoolean 会将参数转换为一个布尔类型的值，见表 9：

表 9: ToBoolean 转换

参数类型	Result
Undefined	Return false.
Null	Return false.
Boolean	Return `argument`.
Number	If `argument` is +0, -0, or NaN, return false; otherwise return true.
String	If `argument` is the empty String (its length is zero), return false; otherwise return true.
Symbol	Return true.
Object	Return true.

7.1.3ToNumber ( `argument` )

抽象操作 ToNumber 会将参数转换为一个数值类型的值，见表 10：

表 10: ToNumber 转换

参数类型	Result
Undefined	Return NaN.
Null	Return +0.
Boolean	If `argument` is true, return 1. If `argument` is false, return +0.
Number	Return `argument` (no conversion).
String	See grammar and conversion 算法 below.
Symbol	抛出一个 TypeError 异常.
Object	Apply the following steps: Let `primValue` be ? ToPrimitive(`argument`, hint Number). Return ? ToNumber(`primValue`).

7.1.3.1对字符串类型应用 ToNumber

被应用在字符串上的 ToNumber 抽象操作会对输入的字符串（被作为 UTF-16 编码的码点 (6.1.4) 序列来解释）应用以下语法。如果这个语法不能把该字符串解释为一个 StringNumericLiteral 的延伸，那么 ToNumber 的结果会是 NaN。

Note 1

这种语法的终止符都是由 Unicode BMP 码点组成，因此如果字符串包含任何附加码点或任何未成对代理码点的 UTF-16 编码，那么这个结果会是 NaN。

Syntax

:::

opt

opt

opt

:::

opt

:::

:::

:::

:::

Infinity

opt

opt

opt

opt

所有的上面未显式定义的文法符号都有被用在数值型字面量 (11.8.3) 的词法定义。

Note 2

一些存在在一个字符串数值型字面量和一个数值型字面量之间的差异应该被注意：

A StringNumericLiteral may include leading and/or trailing 空白 and/or 行终止符.
A StringNumericLiteral that is decimal may have any number of leading 0 digits.
A StringNumericLiteral that is decimal may include a + or - to indicate its sign.
A StringNumericLiteral that is empty or contains only 空白 is converted to +0.
Infinity and -Infinity are recognized as a StringNumericLiteral but not as a NumericLiteral.

7.1.3.1.1运行时语义: MV

字符串到数字值的转换，大体上类似于数值型字面量 (see 11.8.3) 的判定，不过细节上有些不同，所以，这里给出了把字符型数字字面量转换为数值类型的值的过程。这个值分两步来判定：首先，一个数学值 (MV) 来自于字符型数值字面量中；第二步，以下面所描述的方式对该数学值进行舍入。在任何文法符号上的这个 MV （下面未提供的），是定义在 11.8.3.1 中的符号的 MV。

The MV of StringNumericLiteral:::[empty] is 0.
The MV of StringNumericLiteral:::StrWhiteSpace is 0.
The MV of StringNumericLiteral:::StrWhiteSpaceoptStrNumericLiteralStrWhiteSpaceopt is the MV of StrNumericLiteral, no matter whether 空白 is present or not.
The MV of StrNumericLiteral:::StrDecimalLiteral is the MV of StrDecimalLiteral.
The MV of StrNumericLiteral:::BinaryIntegerLiteral is the MV of BinaryIntegerLiteral.
The MV of StrNumericLiteral:::OctalIntegerLiteral is the MV of OctalIntegerLiteral.
The MV of StrNumericLiteral:::HexIntegerLiteral is the MV of HexIntegerLiteral.
The MV of StrDecimalLiteral:::StrUnsignedDecimalLiteral is the MV of StrUnsignedDecimalLiteral.
The MV of StrDecimalLiteral:::+StrUnsignedDecimalLiteral is the MV of StrUnsignedDecimalLiteral.
The MV of StrDecimalLiteral:::-StrUnsignedDecimalLiteral is the negative of the MV of StrUnsignedDecimalLiteral. (Note that if the MV of StrUnsignedDecimalLiteral is 0, the negative of this MV is also 0. The rounding rule described below handles the conversion of this signless mathematical zero to a floating-point +0 or -0 as appropriate.)
The MV of StrUnsignedDecimalLiteral:::Infinity is 10¹⁰⁰⁰⁰ (a value so large that it will round to +∞).
The MV of StrUnsignedDecimalLiteral:::DecimalDigits. is the MV of DecimalDigits.
The MV of StrUnsignedDecimalLiteral:::DecimalDigits.DecimalDigits is the MV of the first DecimalDigits plus (the MV of the second DecimalDigits times 10^-n), where n is the number of code points in the second DecimalDigits.
The MV of StrUnsignedDecimalLiteral:::DecimalDigits.ExponentPart is the MV of DecimalDigits times 10^e, where e is the MV of ExponentPart.
The MV of StrUnsignedDecimalLiteral:::DecimalDigits.DecimalDigitsExponentPart is (the MV of the first DecimalDigits plus (the MV of the second DecimalDigits times 10^-n)) times 10^e, where n is the number of code points in the second DecimalDigits and e is the MV of ExponentPart.
The MV of StrUnsignedDecimalLiteral:::.DecimalDigits is the MV of DecimalDigits times 10^-n, where n is the number of code points in DecimalDigits.
The MV of StrUnsignedDecimalLiteral:::.DecimalDigitsExponentPart is the MV of DecimalDigits times 10^e-n, where n is the number of code points in DecimalDigits and e is the MV of ExponentPart.
The MV of StrUnsignedDecimalLiteral:::DecimalDigits is the MV of DecimalDigits.
The MV of StrUnsignedDecimalLiteral:::DecimalDigitsExponentPart is the MV of DecimalDigits times 10^e, where e is the MV of ExponentPart.

一旦字符型数值字面量的 MV 被精确地确定，接下来就会被舍入为数值类型的一个值。如果 MV 是 0，那么舍入值为 +0，除非字符型数值字面量中第一个非空白字符是 "-" ，在这种情况下，舍入值为 -0。否则，MV （定义在 6.1.6）的舍入值必须是数值类型的值，除非该字面量包括一个 StrUnsignedDecimalLiteral ，且此字面量多于 20 位的有效数字，在这种情况下，对于一个字面量的 MV，其值会是下面两种之一：一是将其 20 位之后的每一位有效数字用 0 替换，产生此字面量的 MV 的值；二是将其 20 位之后的每个有效数字用 0 替换，并在第 20 位有效数字上加一，产生此字面量的 MV 的值。判断一个数字是否为有效数字，首先它不能是 ExponentPart 的一部分，且

它不是 0；或
它的左边是一个非零数字，且右边是一个不在 ExponentPart 中的非零数字。

7.1.4ToInteger ( `argument` )

ToInteger 抽象操作将其参数 argument 转换为一个整数值。此抽象操作运行如下：

Let number be ? ToNumber(argument).
If number is NaN, return +0.
If number is +0, -0, +∞, or -∞, return number.
Return the Number 值 that is the same sign as number and whose magnitude is floor(abs(number)).

7.1.5ToInt32 ( `argument` )

ToInt32 抽象操作将其参数 argument 转换为在闭区间 -2³¹ 到 2³¹-1 范围内的其中一个 2³² 位的整数值。此抽象操作运行如下：

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int32bit be int modulo 2³².
If int32bit ≥ 2³¹, return int32bit - 2³²; otherwise return int32bit.

Note

Given the above definition of ToInt32:

The ToInt32 抽象操作 is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
ToInt32(ToUint32(x)) is equal to ToInt32(x) for all values of x. (It is to preserve this latter property that +∞ and -∞ are mapped to +0.)
ToInt32 maps -0 to +0.

7.1.6ToUint32 ( `argument` )

ToUint32 抽象操作将其参数 argument 转换为在闭区间 0 到 2³¹-1 范围内的其中一个 2³² 位的整数值。此抽象操作运行如下：

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int32bit be int modulo 2³².
Return int32bit.

Note

Given the above definition of ToUint32:

Step 5 is the only difference between ToUint32 and ToInt32.
The ToUint32 抽象操作 is idempotent: if applied to a result that it produced, the second application leaves that value unchanged.
ToUint32(ToInt32(x)) is equal to ToUint32(x) for all values of x. (It is to preserve this latter property that +∞ and -∞ are mapped to +0.)
ToUint32 maps -0 to +0.

7.1.7ToInt16 ( `argument` )

ToInt16 抽象操作将其参数 argument 转换为在闭区间 -32768 到 32767 范围内的其中一个 2¹⁶ 位的整数值。此抽象操作运行如下：

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int16bit be int modulo 2¹⁶.
If int16bit ≥ 2¹⁵, return int16bit - 2¹⁶; otherwise return int16bit.

7.1.8ToUint16 ( `argument` )

The 抽象操作 ToUint16 converts argument to one of 2¹⁶ integer values in the range 0 through 2¹⁶-1, inclusive. This 抽象操作 functions as follows:ToUint16 抽象操作将其参数 argument 转换为在闭区间 0 到 2¹⁶-1 范围内的其中一个 2¹⁶ 位的整数值。此抽象操作运行如下：

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int16bit be int modulo 2¹⁶.
Return int16bit.

Note

Given the above definition of ToUint16:

The substitution of 2¹⁶ for 2³² in step 4 is the only difference between ToUint32 and ToUint16.
ToUint16 maps -0 to +0.

7.1.9ToInt8 ( `argument` )

The 抽象操作 ToInt8 converts argument to one of 2⁸ integer values in the range -128 through 127, inclusive. This 抽象操作 functions as follows:

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int8bit be int modulo 2⁸.
If int8bit ≥ 2⁷, return int8bit - 2⁸; otherwise return int8bit.

7.1.10ToUint8 ( `argument` )

The 抽象操作 ToUint8 converts argument to one of 2⁸ integer values in the range 0 through 255, inclusive. This 抽象操作 functions as follows:

Let number be ? ToNumber(argument).
If number is NaN, +0, -0, +∞, or -∞, return +0.
Let int be the 数学值 that is the same sign as number and whose magnitude is floor(abs(number)).
Let int8bit be int modulo 2⁸.
Return int8bit.

7.1.11ToUint8Clamp ( `argument` )

The 抽象操作 ToUint8Clamp converts argument to one of 2⁸ integer values in the range 0 through 255, inclusive. This 抽象操作 functions as follows:

Let number be ? ToNumber(argument).
If number is NaN, return +0.
If number ≤ 0, return +0.
If number ≥ 255, return 255.
Let f be floor(number).
If f + 0.5 < number, return f + 1.
If number < f + 0.5, return f.
If f is odd, return f + 1.
Return f.

Note

Unlike the other ES integer conversion 抽象操作, ToUint8Clamp rounds rather than truncates non-integer values and does not convert +∞ to 0. ToUint8Clamp does “round half to even” tie-breaking. This differs from Math.round which does “round half up” tie-breaking.

7.1.12ToString ( `argument` )

抽象操作 ToString 会将参数转换为一个字符型的值，见表 11：

表 11: ToString 转换

参数类型	Result
Undefined	Return `"undefined"`.
Null	Return `"null"`.
Boolean	If `argument` is true, return `"true"`. If `argument` is false, return `"false"`.
Number	Return NumberToString(`argument`).
String	Return `argument`.
Symbol	抛出一个 TypeError 异常.
Object	Apply the following steps: Let `primValue` be ? ToPrimitive(`argument`, hint String). Return ? ToString(`primValue`).

7.1.12.1NumberToString ( `m` )

NumberToString 抽象操作将其数值型参数 m 转换为一个字符型格式的值，如下所示：

If m is NaN, return the String "NaN".
If m is +0 or -0, return the String "0".
If m is less than zero, return the string-concatenation of "-" and ! ToString(-m).
If m is +∞, return the String "Infinity".
Otherwise, let n, k, and s be integers such that k ≥ 1, 10^k-1 ≤ s < 10^k, the Number 值 for s × 10^n-k is m, and k is as small as possible. Note that k is the number of digits in the decimal representation of s, that s is not divisible by 10, and that the least significant digit of s is not necessarily uniquely determined by these criteria.
If k ≤ n ≤ 21, return the string-concatenation of:
- the 代码单元 of the k digits of the decimal representation of s (in order, with no leading zeroes)
- n-k occurrences of the 代码单元 0x0030 (DIGIT ZERO)
If 0 < n ≤ 21, return the string-concatenation of:
- the 代码单元 of the most significant n digits of the decimal representation of s
- the 代码单元 0x002E (FULL STOP)
- the 代码单元 of the remaining k-n digits of the decimal representation of s
If -6 < n ≤ 0, return the string-concatenation of:
- the 代码单元 0x0030 (DIGIT ZERO)
- the 代码单元 0x002E (FULL STOP)
- -n occurrences of the 代码单元 0x0030 (DIGIT ZERO)
- the 代码单元 of the k digits of the decimal representation of s
Otherwise, if k = 1, return the string-concatenation of:
- the 代码单元 of the single digit of s
- the 代码单元 0x0065 (LATIN SMALL LETTER E)
- the 代码单元 0x002B (PLUS SIGN) or the 代码单元 0x002D (HYPHEN-MINUS) according to whether n-1 is positive or negative
- the 代码单元 of the decimal representation of the integer abs(n-1) (with no leading zeroes)
Return the string-concatenation of:
- the 代码单元 of the most significant digit of the decimal representation of s
- the 代码单元 0x002E (FULL STOP)
- the 代码单元 of the remaining k-1 digits of the decimal representation of s
- the 代码单元 0x0065 (LATIN SMALL LETTER E)
- the 代码单元 0x002B (PLUS SIGN) or the 代码单元 0x002D (HYPHEN-MINUS) according to whether n-1 is positive or negative
- the 代码单元 of the decimal representation of the integer abs(n-1) (with no leading zeroes)

Note 1

下面的意见可能对实现指导有用，但并不是本标准的常规要求的一部分：

If x is any Number 值 other than -0, then ToNumber(ToString(x)) is exactly the same Number 值 as x.
The least significant digit of s is not always uniquely determined by the requirements listed in step 5.

Note 2

对于那些提供了比上面的规则所要求的更精确的转换的实现，将下面这个步骤 5 的可选版本作为指导是被推荐的：

Otherwise, let n, k, and s be integers such that k ≥ 1, 10^k-1 ≤ s < 10^k, the Number 值 for s × 10^n-k is m, and k is as small as possible. If there are multiple possibilities for s, choose the value of s for which s × 10^n-k is closest in value to m. If there are two such possible values of s, choose the one that is even. Note that k is the number of digits in the decimal representation of s and that s is not divisible by 10.

Note 3

Implementers of ES may find useful the paper and code written by David M. Gay for binary-to-decimal conversion of floating-point numbers:

Gay, David M. Correctly Rounded Binary-Decimal and Decimal-Binary Conversions. Numerical Analysis, Manuscript 90-10. AT&T Bell Laboratories (Murray Hill, New Jersey). November 30, 1990. Available as
http://ampl.com/REFS/abstracts.html#rounding. Associated code available as
http://netlib.sandia.gov/fp/dtoa.c and as
http://netlib.sandia.gov/fp/g_fmt.c and may also be found at the various netlib mirror sites.

7.1.13ToObject ( `argument` )

ToObject 抽象操作根据表 12 将其参数 argument 转换为一个对象类型的值：

表 12: ToObject 转换

参数类型	Result
Undefined	抛出一个 TypeError 异常.
Null	抛出一个 TypeError 异常.
Boolean	Return a new Boolean 对象 whose [[BooleanData]] 内部属性 is set to `argument`. See 19.3 for a description of 布尔对象.
Number	Return a new Number 对象 whose [[NumberData]] 内部属性 is set to `argument`. See 20.1 for a description of 数字对象.
String	Return a new String 对象 whose [[StringData]] 内部属性 is set to `argument`. See 21.1 for a description of 字符串对象.
Symbol	Return a new Symbol 对象 whose [[SymbolData]] 内部属性 is set to `argument`. See 19.4 for a description of 符号对象.
Object	Return `argument`.

7.1.14ToPropertyKey ( `argument` )

ToPropertyKey 抽象操作通过执行以下步骤将其参数 argument 转换为一个可以用来作为一个属性键的值：

Let key be ? ToPrimitive(argument, hint String).
If Type(key) is Symbol, then
1. Return key.
Return ! ToString(key).

7.1.15ToLength ( `argument` )

ToLength 抽象操作通过执行以下步骤将其参数 argument 转换为一个适合作为一个类数组对象长度的整数值：

Let len be ? ToInteger(argument).
If len ≤ +0, return +0.
Return min(len, 2⁵³-1).

7.1.16CanonicalNumericIndexString ( `argument` )

The 抽象操作 CanonicalNumericIndexString returns argument converted to a 数字值 if it is a String representation of a Number that would be produced by ToString, or the string "-0". Otherwise, it returns undefined. This 抽象操作 functions as follows:

Assert: Type(argument) is String.
If argument is "-0", return -0.
Let n be ! ToNumber(argument).
If SameValue(! ToString(n), argument) is false, return undefined.
Return n.

A canonical numeric string is any String 值 for which the CanonicalNumericIndexString 抽象操作 does not return undefined.

7.1.17ToIndex ( `val、ue` )

The 抽象操作 ToIndex returns value argument converted to a 数字值 if it is a valid 整数索引 value. This 抽象操作 functions as follows:

If value is undefined, then
1. Let index be 0.
Else,
1. Let integerIndex be ? ToInteger(value).
2. If integerIndex < 0, 抛出一个 RangeError 异常.
3. Let index be ! ToLength(integerIndex).
4. If SameValueZero(integerIndex, index) is false, 抛出一个 RangeError 异常.
Return index.

7.2测试和比较操作

7.2.1RequireObjectCoercible ( `argument` )

如果参数 argument 是一个使用 ToObject 方法后无法转换为一个对象的值，那么抽象操作 RequireObjectCoercible 抛出一个错误。它由表 13 定义：

Table 13: RequireObjectCoercible Results

参数类型	Result
Undefined	抛出一个 TypeError 异常.
Null	抛出一个 TypeError 异常.
Boolean	Return `argument`.
Number	Return `argument`.
String	Return `argument`.
Symbol	Return `argument`.
Object	Return `argument`.

7.2.2IsArray ( `argument` )

抽象操作 IsArray 携带有一个参数 argument, 和将执行以下步骤：

If Type(argument) is not Object, return false.
If argument is an Array 外来对象, return true.
If argument is a Proxy 外来对象, then
1. If argument.[[ProxyHandler]] is null, 抛出一个 TypeError 异常.
2. Let target be argument.[[ProxyTarget]].
3. Return ? IsArray(target).
Return false.

7.2.3IsCallable ( `argument` )

抽象操作 IsCallable 判定其参数 argument（必须是一个 ES 语言值）是否是一个携带有 [[Call]] 内部方法的可被调用函数。

If Type(argument) is not Object, return false.
If argument has a [[Call]] 内部方法, return true.
Return false.

7.2.4IsConstructor ( `argument` )

抽象操作 IsConstructor 判定其参数 argument（必须是一个 ES 语言值）是否是一个携带有 [[Construct]] 内部方法的函数对象。

If Type(argument) is not Object, return false.
If argument has a [[Construct]] 内部方法, return true.
Return false.

7.2.5IsExtensible ( `O` )

抽象操作 IsExtensible 用来判定额外的属性是否可以被添加在对象 O 上。其会返回一个布尔值。该抽象操作会执行如下步骤：

Assert: Type(O) is Object.
Return ? O.[[IsExtensible]]().

7.2.6IsInteger ( `argument` )

抽象操作 IsInteger 判定其参数 argument 是否是一个有限的整数值。

If Type(argument) is not Number, return false.
If argument is NaN, +∞, or -∞, return false.
If floor(abs(argument)) ≠ abs(argument), return false.
Return true.

7.2.7IsPropertyKey ( `argument` )

抽象操作 IsPropertyKey 判定一个参数 argument （ES 语言值）是否是一个可以用来作为一个属性键的值。

If Type(argument) is String, return true.
If Type(argument) is Symbol, return true.
Return false.

7.2.8IsRegExp ( `argument` )

携带有参数 argument 的抽象操作 IsRegExp 将会执行以下步骤：

If Type(argument) is not Object, return false.
Let matcher be ? Get(argument, @@match).
If matcher is not undefined, return ToBoolean(matcher).
If argument has a [[RegExpMatcher]] 内部属性, return true.
Return false.

7.2.9IsStringPrefix ( `p`, `q` )

抽象操作 IsStringPrefix 判定字符串 p 是否是字符串 q 的前缀。

Assert: Type(p) is String.
Assert: Type(q) is String.
If q can be the string-concatenation of p and some other String r, return true. Otherwise, return false.
NOTE: Any String is a prefix of itself, because r may be the empty String.

7.2.10SameValue ( `x`, `y` )

内部比较抽象操作 SameValue(x, y) （其参数 x 和 y 都是 ES 语言值）会返回 true 或 false。比较过程执行如下：

If Type(x) is different from Type(y), return false.
If Type(x) is Number, then
1. If x is NaN and y is NaN, return true.
2. If x is +0 and y is -0, return false.
3. If x is -0 and y is +0, return false.
4. If x is the same Number 值 as y, return true.
5. Return false.
Return SameValueNonNumber(x, y).

Note

该算法与严格相等比较的算法的区别在于有符号 0 和 NaNs 的比较。在本算法中，+0 和 -0 是不相等的，但 NaN 的比较是相等的，而严格相等比较的算法反之。

7.2.11SameValueZero ( `x`, `y` )

内部比较抽象操作 SameValueZero(x, y) （其参数 x 和 y 都是 ES 语言值）会返回 true 或 false。比较过程执行如下：

If Type(x) is different from Type(y), return false.
If Type(x) is Number, then
1. If x is NaN and y is NaN, return true.
2. If x is +0 and y is -0, return true.
3. If x is -0 and y is +0, return true.
4. If x is the same Number 值 as y, return true.
5. Return false.
Return SameValueNonNumber(x, y).

Note

SameValueZero 与 SameValue 这两个抽象操作之间唯一的不同就是在对待 +0 和 -0 的比较问题上，前者认为 +0 和 -0 是相等的，后者则相反。

7.2.12SameValueNonNumber ( `x`, `y` )

内部比较抽象操作 SameValueNonNumber(x, y) （其参数 x 和 y 都不是数值型的值），会返回 true 或 false。该比较执行如下：

Assert: Type(x) is not Number.
Assert: Type(x) is the same as Type(y).
If Type(x) is Undefined, return true.
If Type(x) is Null, return true.
If Type(x) is String, then
1. If x and y are exactly the same sequence of 代码单元 (same length and same 代码单元 at corresponding indices), return true; otherwise, return false.
If Type(x) is Boolean, then
1. If x and y are both true or both false, return true; otherwise, return false.
If Type(x) is Symbol, then
1. If x and y are both the same Symbol 值, return true; otherwise, return false.
If x and y are the same Object value, return true. Otherwise, return false.

7.2.13抽象关系比较

该比较 x < y, 其操作数 x 和 y 的都是 ES 语言值，会返回 true 或 false 或 undefined (表明至少有一个操作数是 NaN). In addition to x and y the 算法 takes a Boolean flag named LeftFirst as a parameter. The flag is used to control the order in which operations with potentially visible side-effects are performed upon x and y. It is necessary because ES specifies left to right 估值 of expressions. The 默认值 of LeftFirst is true and indicates that the x parameter corresponds to an expression that occurs to the left of the y parameter's corresponding expression. If LeftFirst is false, the reverse is the case and operations must be performed upon y before x. Such a comparison is performed as follows:

If the LeftFirst flag is true, then
1. Let px be ? ToPrimitive(x, hint Number).
2. Let py be ? ToPrimitive(y, hint Number).
Else the order of 估值 needs to be reversed to preserve left to right 估值,
1. Let py be ? ToPrimitive(y, hint Number).
2. Let px be ? ToPrimitive(x, hint Number).
If Type(px) is String and Type(py) is String, then
1. If IsStringPrefix(py, px) is true, return false.
2. If IsStringPrefix(px, py) is true, return true.
3. Let k be the smallest nonnegative integer such that the 代码单元 at index k within px is different from the 代码单元 at index k within py. (There must be such a k, for neither String is a prefix of the other.)
4. Let m be the integer that is the 数字值 of the 代码单元 at index k within px.
5. Let n be the integer that is the 数字值 of the 代码单元 at index k within py.
6. If m < n, return true. Otherwise, return false.
Else,
1. NOTE: Because px and py are primitive values 估值 order is not important.
2. Let nx be ? ToNumber(px).
3. Let ny be ? ToNumber(py).
4. If nx is NaN, return undefined.
5. If ny is NaN, return undefined.
6. If nx and ny are the same Number 值, return false.
7. If nx is +0 and ny is -0, return false.
8. If nx is -0 and ny is +0, return false.
9. If nx is +∞, return false.
10. If ny is +∞, return true.
11. If ny is -∞, return false.
12. If nx is -∞, return true.
13. If the 数学值 of nx is less than the 数学值 of ny—note that these mathematical values are both finite and not both zero—return true. Otherwise, return false.

Note 1

Step 3 differs from step 7 in the 算法 for 加运算符 + (12.8.3) by using the 逻辑与运算 instead of the 逻辑或运算.

Note 2

The comparison of Strings uses a simple lexicographic ordering on sequences of 代码单元 values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore String values that are canonically equal according to the Unicode standard could test as unequal. In effect this 算法 assumes that both Strings are already in normalized form. Also, note that for strings containing supplementary characters, lexicographic ordering on sequences of UTF-16 代码单元 values differs from that on sequences of 码点 values.

7.2.14抽象相等比较

该比较 x == y，其操作数 x 和 y 都是 ES 语言值，会返回 true 或 false。执行如下：

If Type(x) is the same as Type(y), then
1. Return the result of performing 严格相等比较 x === y.
If x is null and y is undefined, return true.
If x is undefined and y is null, return true.
If Type(x) is Number and Type(y) is String, return the result of the comparison x == ! ToNumber(y).
If Type(x) is String and Type(y) is Number, return the result of the comparison ! ToNumber(x) == y.
If Type(x) is Boolean, return the result of the comparison ! ToNumber(x) == y.
If Type(y) is Boolean, return the result of the comparison x == ! ToNumber(y).
If Type(x) is either String, Number, or Symbol and Type(y) is Object, return the result of the comparison x == ToPrimitive(y).
If Type(x) is Object and Type(y) is either String, Number, or Symbol, return the result of the comparison ToPrimitive(x) == y.
Return false.

7.2.15严格相等比较

该比较 x === y（其 x 和 y 的值都是 ES 语言值），会返回 true 或 false。该算法会执行如下：

If Type(x) is different from Type(y), return false.
If Type(x) is Number, then
1. If x is NaN, return false.
2. If y is NaN, return false.
3. If x is the same Number 值 as y, return true.
4. If x is +0 and y is -0, return true.
5. If x is -0 and y is +0, return true.
6. Return false.
Return SameValueNonNumber(x, y).

Note

This 算法 differs from the SameValue 算法 in its treatment of signed zeroes and NaNs.该算法与 SameValue 的算法的区别在于有符号 0 和 NaNs 的比较。在本算法中，+0 和 -0 是相等的，但 NaN 的比较是不相等的，而 SameValue 的算法反之。

7.3对象操作

7.3.1Get ( `O`, `P` )

抽象操作 Get 用来检索对象上一个指定的属性的值。该操作会携带参数 O 和 P （O 是一个对象，P 是一个属性键）。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Return ? O.[[Get]](P, O).

7.3.2GetV ( `V`, `P` )

抽象操作 GetV 用来检索一个 ES 语言值的一个指定的属性的值。如果该值不是一个对象，则使用适合于该值类型的一个包装器对象来执行属性查找。该操作会被以携带参数 V 和 P （V 是一个 ES 语言值，P 是一个属性键）的形式调用。执行如下：

Assert: IsPropertyKey(P) is true.
Let O be ? ToObject(V).
Return ? O.[[Get]](P, V).

7.3.3Set ( `O`, `P`, `V`, `Throw` )

抽象操作 Set 用来设置对象的一个指定的属性的值。该操作会被以携带参数 O, P, V, 和 Throw（O 是一个对象，P 是该属性的键，V 是该属性的新值，Throw 是一个布尔标志）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Assert: Type(Throw) is Boolean.
Let success be ? O.[[Set]](P, V, O).
If success is false and Throw is true, 抛出一个 TypeError 异常.
Return success.

7.3.4CreateDataProperty ( `O`, `P`, `V` )

抽象操作CreateDataProperty 用来创建一个对象的新的自身属性。该操作会被以携带参数 O, P, 和 V （O 是该对象，P 是该属性的键，V 是该属性的值）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let newDesc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}.
Return ? O.[[DefineOwnProperty]](P, newDesc).

Note

该抽象操作创建一个属性，其特性被设置为与通过 ES 语言分配符所创建的属性一样的默认值。通常情况下，属性是不存在的。如果它确实存在，则是不可配置的，或者如果对象 O 是不可扩展的，[[DefineOwnProperty]] 将返回 false。

7.3.5CreateMethodProperty ( `O`, `P`, `V` )

抽象操作 CreateMethodProperty 用来创建一个对象的新的自身属性。该操作会被以携带参数 O, P, 和 V （O 是该对象，P 是该属性的键，V 是该属性的值）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let newDesc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
Return ? O.[[DefineOwnProperty]](P, newDesc).

Note

该抽象操作创建一个属性，其特性被设置为与使用类声明语句所定义的内置方法一样的默认值。通常情况下，属性是不存在的。如果它确实存在，则是不可配置的，或者如果对象 O 是不可扩展的，[[DefineOwnProperty]] 将返回 false。

7.3.6CreateDataPropertyOrThrow ( `O`, `P`, `V` )

抽象操作 CreateDataPropertyOrThrow 用来创建对象的一个新的自身属性。如果属性更新请求不能被执行，它将会抛出一个 TypeError 异常。该操作会被以携带参数 O, P, V（O 是一个对象，P 是该属性的键，V 是该属性的新值）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let success be ? CreateDataProperty(O, P, V).
If success is false, 抛出一个 TypeError 异常.
Return success.

Note

该抽象操作创建一个属性，其特性被设置为与通过 ES 语言分配符所创建的属性一样的默认值。通常情况下，属性是不存在的。如果它确实存在，则是不可配置的，或者如果对象 O 是不可扩展的，[[DefineOwnProperty]] 将返回 false 并导致该操作会抛出一个 TypeError 异常。

7.3.7DefinePropertyOrThrow ( `O`, `P`, `desc` )

抽象操作 DefinePropertyOrThrow 以一种如果属性更新请求不能被执行，它将会抛出 TypeError 异常的方式来调用一个对象的 [[DefineOwnProperty]] 内部方法。该操作会被以携带参数 O, P 和 desc（O 是一个对象，P 是该属性的键，desc 是该属性的属性描述符）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let success be ? O.[[DefineOwnProperty]](P, desc).
If success is false, 抛出一个 TypeError 异常.
Return success.

7.3.8DeletePropertyOrThrow ( `O`, `P` )

抽象操作 DeletePropertyOrThrow 用来移除对象的一个指定的自身属性。如果该属性是不可配置的，它将会抛出一个 TypeError 异常。该操作会被以携带参数 O, P（O 是一个对象，P 是该属性的键）的形式调用。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let success be ? O.[[Delete]](P).
If success is false, 抛出一个 TypeError 异常.
Return success.

7.3.9GetMethod ( `V`, `P` )

The 抽象操作 GetMethod is used to get the value of a specific property of an ES 语言值 when the value of the property is expected to be a function. The operation is called with arguments V and P where V is the ES 语言值, P is the property key. This 抽象操作执行如下:抽象操作 GetMethod 用来获取一个 ES 语言值的一个指定的属性的值（当该属性的值被期待是一个函数时）。该操作会被以携带参数 V 和 P （V 是一个 ES 语言值，P 是一个属性键）的形式调用。执行如下：

Assert: IsPropertyKey(P) is true.
Let func be ? GetV(V, P).
If func is either undefined or null, return undefined.
If IsCallable(func) is false, 抛出一个 TypeError 异常.
Return func.

7.3.10HasProperty ( `O`, `P` )

抽象操作 HasProperty 用来判定一个对象上是否有一个指定属性键的属性。该属性可以是自身的或者继承的。该操作会返回一个布尔值。该操作会携带参数 O 和 P （O 是一个对象，P 是一个属性键）。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Return ? O.[[HasProperty]](P).

7.3.11HasOwnProperty ( `O`, `P` )

抽象操作 HasOwnProperty 用来判定一个对象上是否有一个指定属性键的自身属性。该操作会返回一个布尔值。该操作会携带参数 O 和 P （O 是一个对象，P 是一个属性键）。执行如下：

Assert: Type(O) is Object.
Assert: IsPropertyKey(P) is true.
Let desc be ? O.[[GetOwnProperty]](P).
If desc is undefined, return false.
Return true.

7.3.12Call ( `F`, `V` [ , `argumentsList` ] )

抽象操作 Call 用来调用一个函数对象的 [[Call]] 内部方法。该操作会被以携带参数 F, V, 和可选的 argumentsList （F 是该函数对象，V 是一个 ES 语言值（即 [[Call]] 的 this 值），argumentsList 是内部方法的响应参数传递过来的值）的形式调用。如果 argumentsList 参数不存在，一个新的空列表会被用来作为它的值。执行如下：

If argumentsList is not present, set argumentsList to a new empty List.
If IsCallable(F) is false, 抛出一个 TypeError 异常.
Return ? F.[[Call]](V, argumentsList).

7.3.13Construct ( `F` [ , `argumentsList` [ , `newTarget` ]] )

抽象操作 Construct 用来调用一个函数对象的 [[Construct]] 内部方法。该操作会被以携带参数 F, 和可选的 argumentsList，和可选的 newTarget（F 是该函数对象，argumentsList 和 newTarget 是内部方法的响应参数传递过来的值）的形式调用。如果 argumentsList 参数不存在，一个新的空列表会被用来作为它的值。如果 newTarget 不存在，F 被用来作为它的值。执行如下：

If newTarget is not present, set newTarget to F.
If argumentsList is not present, set argumentsList to a new empty List.
Assert: IsConstructor(F) is true.
Assert: IsConstructor(newTarget) is true.
Return ? F.[[Construct]](argumentsList, newTarget).

Note

If newTarget is not present, this operation is equivalent to: new F(...argumentsList)

7.3.14SetIntegrityLevel ( `O`, `level` )

抽象操作 SetIntegrityLevel 用来固定对象的自身属性的集合。算法如下：

Assert: Type(O) is Object.
Assert: level is either "sealed" or "frozen".
Let status be ? O.[[PreventExtensions]]().
If status is false, return false.
Let keys be ? O.[[OwnPropertyKeys]]().
If level is "sealed", then
1. For each element k of keys, do
  1. Perform ? DefinePropertyOrThrow(O, k, PropertyDescriptor{[[Configurable]]: false}).
Else level is "frozen",
1. For each element k of keys, do
  1. Let currentDesc be ? O.[[GetOwnProperty]](k).
  2. If currentDesc is not undefined, then
    1. If IsAccessorDescriptor(currentDesc) is true, then
      1. Let desc be the PropertyDescriptor{[[Configurable]]: false}.
    2. Else,
      1. Let desc be the PropertyDescriptor { [[Configurable]]: false, [[Writable]]: false }.
    3. Perform ? DefinePropertyOrThrow(O, k, desc).
Return true.

7.3.15TestIntegrityLevel ( `O`, `level` )

The 抽象操作 TestIntegrityLevel is used to determine if the set of 自身属性 of an object are fixed. This 抽象操作执行如下:

Assert: Type(O) is Object.
Assert: level is either "sealed" or "frozen".
Let status be ? IsExtensible(O).
If status is true, return false.
NOTE: If the object is extensible, none of its properties are examined.
Let keys be ? O.[[OwnPropertyKeys]]().
For each element k of keys, do
1. Let currentDesc be ? O.[[GetOwnProperty]](k).
2. If currentDesc is not undefined, then
  1. If currentDesc.[[Configurable]] is true, return false.
  2. If level is "frozen" and IsDataDescriptor(currentDesc) is true, then
    1. If currentDesc.[[Writable]] is true, return false.
Return true.

7.3.16CreateArrayFromList ( `elements` )

The 抽象操作 CreateArrayFromList is used to create an Array object whose elements are provided by a List. This 抽象操作执行如下:

Assert: elements is a List whose elements are all ES 语言值.
Let array be ! ArrayCreate(0).
Let n be 0.
For each element e of elements, do
1. Let status be CreateDataProperty(array, ! ToString(n), e).
2. Assert: status is true.
3. Increment n by 1.
Return array.

7.3.17CreateListFromArrayLike ( `obj` [ , `elementTypes` ] )

The 抽象操作 CreateListFromArrayLike is used to create a List value whose elements are provided by the indexed properties of an array-like object, obj. The 可选参数 elementTypes is a List containing the names of ES 语言类型 that are allowed for element values of the List that is created. This 抽象操作执行如下:

If elementTypes is not present, set elementTypes to « Undefined, Null, Boolean, String, Symbol, Number, Object ».
If Type(obj) is not Object, 抛出一个 TypeError 异常.
Let len be ? ToLength(? Get(obj, "length")).
Let list be a new empty List.
Let index be 0.
Repeat, while index < len
1. Let indexName be ! ToString(index).
2. Let next be ? Get(obj, indexName).
3. If Type(next) is not an element of elementTypes, 抛出一个 TypeError 异常.
4. Append next as the last element of list.
5. Set index to index + 1.
Return list.

7.3.18Invoke ( `V`, `P` [ , `argumentsList` ] )

The 抽象操作 Invoke is used to call a method property of an ES 语言值. The operation is called with arguments V, P, and optionally argumentsList where V serves as both the lookup point for the property and the this value of the call, P is the property key, and argumentsList is the list of arguments values passed to the method. If argumentsList is not present, a new empty List is used as its value. This 抽象操作执行如下:

Assert: IsPropertyKey(P) is true.
If argumentsList is not present, set argumentsList to a new empty List.
Let func be ? GetV(V, P).
Return ? Call(func, V, argumentsList).

7.3.19OrdinaryHasInstance ( `C`, `O` )

The 抽象操作 OrdinaryHasInstance implements the default 算法 for determining if an object O inherits from the instance object inheritance path provided by 构造器 C. This 抽象操作执行如下:

If IsCallable(C) is false, return false.
If C has a [[BoundTargetFunction]] 内部属性, then
1. Let BC be C.[[BoundTargetFunction]].
2. Return ? InstanceofOperator(O, BC).
If Type(O) is not Object, return false.
Let P be ? Get(C, "prototype").
If Type(P) is not Object, 抛出一个 TypeError 异常.
Repeat,
1. Set O to ? O.[[GetPrototypeOf]]().
2. If O is null, return false.
3. If SameValue(P, O) is true, return true.

7.3.20SpeciesConstructor ( `O`, `defaultConstructor` )

The 抽象操作 SpeciesConstructor is used to retrieve the 构造器 that should be used to create new objects that are derived from the argument object O. The defaultConstructor argument is the 构造器 to use if a 构造器 @@species property cannot be found starting from O. This 抽象操作执行如下:

Assert: Type(O) is Object.
Let C be ? Get(O, "构造器").
If C is undefined, return defaultConstructor.
If Type(C) is not Object, 抛出一个 TypeError 异常.
Let S be ? Get(C, @@species).
If S is either undefined or null, return defaultConstructor.
If IsConstructor(S) is true, return S.
抛出一个 TypeError 异常.

7.3.21EnumerableOwnPropertyNames ( `O`, `kind` )

When the 抽象操作 EnumerableOwnPropertyNames is called with Object O and String kind 执行如下:

Assert: Type(O) is Object.
Let ownKeys be ? O.[[OwnPropertyKeys]]().
Let properties be a new empty List.
For each element key of ownKeys in List order, do
1. If Type(key) is String, then
  1. Let desc be ? O.[[GetOwnProperty]](key).
  2. If desc is not undefined and desc.[[Enumerable]] is true, then
    1. If kind is "key", append key to properties.
    2. Else,
      1. Let value be ? Get(O, key).
      2. If kind is "value", append value to properties.
      3. Else,
        Assert: kind is "key+value".
        Let entry be CreateArrayFromList(« key, value »).
        Append entry to properties.
Order the elements of properties so they are in the same relative order as would be produced by the 迭代器 that would be returned if the EnumerateObjectProperties 内部方法 were invoked with O.
Return properties.

7.3.22GetFunctionRealm ( `obj` )

The 抽象操作 GetFunctionRealm with argument obj 执行如下:

Assert: obj is a callable object.
If obj has a [[Realm]] 内部属性, then
1. Return obj.[[Realm]].
If obj is a Bound Function 外来对象, then
1. Let target be obj.[[BoundTargetFunction]].
2. Return ? GetFunctionRealm(target).
If obj is a Proxy 外来对象, then
1. If obj.[[ProxyHandler]] is null, 抛出一个 TypeError 异常.
2. Let proxyTarget be obj.[[ProxyTarget]].
3. Return ? GetFunctionRealm(proxyTarget).
Return the current Realm Record.

Note

Step 5 will only be reached if obj is a non-standard function 外来对象 that does not have a [[Realm]] 内部属性.

7.3.23CopyDataProperties (`target`, `source`, `excludedItems`)

When the 抽象操作 CopyDataProperties is called with arguments target, source, and excludedItems, 执行如下:

Assert: Type(target) is Object.
Assert: excludedItems is a List of 属性键.
If source is undefined or null, return target.
Let from be ! ToObject(source).
Let keys be ? from.[[OwnPropertyKeys]]().
For each element nextKey of keys in List order, do
1. Let excluded be false.
2. For each element e of excludedItems in List order, do
  1. If SameValue(e, nextKey) is true, then
    1. Set excluded to true.
3. If excluded is false, then
  1. Let desc be ? from.[[GetOwnProperty]](nextKey).
  2. If desc is not undefined and desc.[[Enumerable]] is true, then
    1. Let propValue be ? Get(from, nextKey).
    2. Perform ! CreateDataProperty(target, nextKey, propValue).
Return target.

Note

The target passed in here is always a newly created object which is not directly accessible in case of an error being thrown.

7.4迭代器对象操作

See Common Iteration Interfaces (25.1).

7.4.1GetIterator ( `obj` [ , `hint` [ , `method` ] ] )

The 抽象操作 GetIterator with argument obj and 可选参数 hint and method 执行如下:

If hint is not present, set hint to sync.
Assert: hint is either sync or async.
If method is not present, then
1. If hint is async, then
  1. Set method to ? GetMethod(obj, @@asyncIterator).
  2. If method is undefined, then
    1. Let syncMethod be ? GetMethod(obj, @@迭代器).
    2. Let syncIteratorRecord be ? GetIterator(obj, sync, syncMethod).
    3. Return ? CreateAsyncFromSyncIterator(syncIteratorRecord).
2. Otherwise, set method to ? GetMethod(obj, @@迭代器).
Let 迭代器 be ? Call(method, obj).
If Type(迭代器) is not Object, 抛出一个 TypeError 异常.
Let nextMethod be ? GetV(迭代器, "next").
Let iteratorRecord be Record {[[迭代器]]: 迭代器, [[NextMethod]]: nextMethod, [[Done]]: false}.
Return iteratorRecord.

7.4.2IteratorNext ( `iteratorRecord` [ , `value` ] )

The 抽象操作 IteratorNext with argument iteratorRecord and 可选参数 value 执行如下:

If value is not present, then
1. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[迭代器]], « »).
Else,
1. Let result be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[迭代器]], « value »).
If Type(result) is not Object, 抛出一个 TypeError 异常.
Return result.

7.4.3IteratorComplete ( `iterResult` )

The 抽象操作 IteratorComplete with argument iterResult 执行如下:

Assert: Type(iterResult) is Object.
Return ToBoolean(? Get(iterResult, "done")).

7.4.4IteratorValue ( `iterResult` )

The 抽象操作 IteratorValue with argument iterResult 执行如下:

Assert: Type(iterResult) is Object.
Return ? Get(iterResult, "value").

7.4.5IteratorStep ( `iteratorRecord` )

The 抽象操作 IteratorStep with argument iteratorRecord requests the next value from iteratorRecord.[[迭代器]] by calling iteratorRecord.[[NextMethod]] and returns either false indicating that the 迭代器 has reached its end or the IteratorResult object if a next value is available. IteratorStep 执行如下:

Let result be ? IteratorNext(iteratorRecord).
Let done be ? IteratorComplete(result).
If done is true, return false.
Return result.

7.4.6IteratorClose ( `iteratorRecord`, `completion` )

The 抽象操作 IteratorClose with arguments iteratorRecord and completion is used to notify an 迭代器 that it should perform any actions it would normally perform when it has reached its completed state:

Assert: Type(iteratorRecord.[[迭代器]]) is Object.
Assert: completion is a 完成记录.
Let 迭代器 be iteratorRecord.[[迭代器]].
Let return be ? GetMethod(迭代器, "return").
If return is undefined, return Completion(completion).
Let innerResult be Call(return, 迭代器, « »).
If completion.[[Type]] is throw, return Completion(completion).
If innerResult.[[Type]] is throw, return Completion(innerResult).
If Type(innerResult.[[Value]]) is not Object, 抛出一个 TypeError 异常.
Return Completion(completion).

7.4.7AsyncIteratorClose ( `iteratorRecord`, `completion` )

The 抽象操作 AsyncIteratorClose with arguments iteratorRecord and completion is used to notify an async 迭代器 that it should perform any actions it would normally perform when it has reached its completed state:

Assert: Type(iteratorRecord.[[迭代器]]) is Object.
Assert: completion is a 完成记录.
Let 迭代器 be iteratorRecord.[[迭代器]].
Let return be ? GetMethod(迭代器, "return").
If return is undefined, return Completion(completion).
Let innerResult be Call(return, 迭代器, « »).
If innerResult.[[Type]] is normal, set innerResult to Await(innerResult.[[Value]]).
If completion.[[Type]] is throw, return Completion(completion).
If innerResult.[[Type]] is throw, return Completion(innerResult).
If Type(innerResult.[[Value]]) is not Object, 抛出一个 TypeError 异常.
Return Completion(completion).

7.4.8CreateIterResultObject ( `value`, `done` )

The 抽象操作 CreateIterResultObject with arguments value and done creates an object that supports the IteratorResult interface by performing the following steps:

Assert: Type(done) is Boolean.
Let obj be ObjectCreate(%ObjectPrototype%).
Perform CreateDataProperty(obj, "value", value).
Perform CreateDataProperty(obj, "done", done).
Return obj.

7.4.9CreateListIteratorRecord ( `list` )

The 抽象操作 CreateListIteratorRecord with argument list creates an 迭代器 (25.1.1.2) object record whose next method returns the successive elements of list. It 执行如下:

Let 迭代器 be ObjectCreate(%IteratorPrototype%, « [[IteratedList]], [[ListIteratorNextIndex]] »).
Set 迭代器.[[IteratedList]] to list.
Set 迭代器.[[ListIteratorNextIndex]] to 0.
Let steps be the 算法步骤 defined in ListIterator next (7.4.9.1).
Let next be CreateBuiltinFunction(steps, « »).
Return Record { [[迭代器]]: 迭代器, [[NextMethod]]: next, [[Done]]: false }.

Note

The list 迭代器 object is never directly accessible to ES 代码.

7.4.9.1ListIterator next( )

The ListIterator next method is a 标准内置函数对象 (clause 17) that 执行如下:

Let O be the this value.
Assert: Type(O) is Object.
Assert: O has an [[IteratedList]] 内部属性.
Let list be O.[[IteratedList]].
Let index be O.[[ListIteratorNextIndex]].
Let len be the number of elements of list.
If index ≥ len, then
1. Return CreateIterResultObject(undefined, true).
Set O.[[ListIteratorNextIndex]] to index+1.
Return CreateIterResultObject(list[index], false).

8可执行代码和执行上下文

8.1词法环境

A 词法环境 is a 规范类型 used to define the association of Identifiers to specific variables and functions based upon the 词法巢式结构 of ES 代码.一个词法环境由一个环境记录和可能为空的外部词法环境引用构成。通常词法环境会与一些特定的 ES 代码的句法结构（诸如 a FunctionDeclaration, a BlockStatement, or a Catch clause of a TryStatement）相联系，且这样的代码每次执行都会有一个新的词法环境被创建。

环境记录记录了在它的关联词法环境域内创建的标识符绑定。它被称为词法环境的 EnvironmentRecord。

外部词法环境引用被用于表示词法环境值的逻辑嵌套关系模型。（内部）词法环境的外部引用是逻辑上包含内部词法环境的词法环境。外部词法环境自然也可能有自己的外部词法环境。一个词法环境也可能充当多个内部词法环境的外部环境。例如，如果一个 FunctionDeclaration 包含两个嵌套的 FunctionDeclaration，那么每个嵌套函数的外部环境都是当前外部函数本次执行所产生的词法环境。

全局环境是一个没有外部环境的词法环境。全局环境的外部环境引用是 null。全局环境的 EnvironmentRecord 或许是用标识符绑定和包含一个关联的全局对象（其属性会提供一些全局环境的标识符绑定）的标识符绑定来填充的。当 ES 代码被执行时，额外的属性可能会被添加到全局对象中，且初始化的属性可能会被修改。

模块环境是一个包含了 Module 的顶层声明的词法环境。它也包含了通过 Module 显式地引入的绑定。模块环境的外部环境是一个全局环境。

函数环境是一个响应 ES 函数对象调用的词法环境。函数环境可能会建立一个新的 this 绑定。一个函数环境也会捕获通过 super 方法调用产生的必要的状态。

词法环境和环境记录值是纯粹的规范机制，不需要与 ES 实现的 any specific artefact 保持一致。ES 程序不可能直接访问或者操作这些值。

8.1.1环境记录

在本规范中，共有两种主要的环境记录值被使用：声明环境记录和对象环境记录 。声明环境记录用于定义 ES 语言句法元素（直接将标识符绑定和 ES 语言值相关联）的效果，例如 FunctionDeclarations, VariableDeclarations, and Catch clauses 。对象环境记录用于定义那些将标识符绑定与一些对象的属性相关联的 ES 元素的效果，例如 WithStatement。全局环境记录和函数环境记录是 specializations that are used for specifically for Script global declarations and for top-level declarations within functions。

出于规范的目的，环境记录值是 Record 规范类型的值，且可以理解为面向对象中的一个简单继承结构，其中环境记录是一个抽象类，有 3 个具体亚类，分别为声明环境记录、对象环境记录和全局环境记录。函数环境记录和模块环境记录是声明环境记录的亚类。这个抽象类包含了定义在表 14 中的抽象规范方法。针对每一个具体的亚类，这些抽象方法都有不同的具体算法。

表 14: 环境记录的抽象方法

Method	Purpose
HasBinding(N)	判断环境记录是否有一个对字符串值 `N` 的绑定。如果有该绑定则返回 true，反之返回 false。（其中字符串 N 是标识符文本。）
CreateMutableBinding(N, D)	在一个环境记录中创建一个新的且未初始化的可变绑定。其中字符串值 `N` 是绑定名称的文本。如果布尔类型的参数 `D` 的值为 true ，则该绑定在后续操作中可以被删除。
CreateImmutableBinding(N, S)	在一个环境记录中创建一个新的且未初始化的不可变绑定。其中字符串值 `N` 是绑定名的文本。如果布尔类型的参数 `S` 的值为 true ，则在它被初始化之后会尝试设置它时会抛出一个异常。不管引用那个绑定的操作是不是在严格模式下。
InitializeBinding(N, V)	在一个环境记录中设置一个已经存在但未初始化的绑定。字符串值 `N` 是绑定名的文本。`V` 是绑定的值，且是任一 ES 语言类型的值。
SetMutableBinding(N, V, S)	在一个环境记录中设置一个已经存在的可变绑定的值。字符串值 `N` 是绑定名的文本。`V` 是绑定的值，且是任一 ES 语言类型的值。`S` 是一个布尔标志。如果 `S` 为 true 且这个绑定不能被设置，那么将抛出一个 TypeError 异常。
GetBindingValue(N, S)	从一个环境记录中返回一个已经存在的绑定的值。字符串值 `N` 是绑定名的文本。`S` 用于指定引用是否发生在严格模式代码下 or that otherwise require 严格模式引用语义。如果 `S` 的值为 true 并且该绑定不存在，则抛出一个 ReferenceError 异常。如果绑定存在且未被初始化，那么，不管 `S` 的值是什么，都会抛出一个 ReferenceError 异常。
DeleteBinding(N)	从环境记录中删除一个绑定。字符串值 `N` 是绑定名的文本。如果 `N` 指定的绑定存在，那么会将其删除并返回 true。如果绑定存在但无法删除则返回 false。如果绑定不存在则返回 true。
HasThisBinding()	判断环境记录中是否建立了一个 `this` 的绑定。如果是则返回 true，反之返回 false。
HasSuperBinding()	判断环境记录中是否建立了一个 `super` 方法的绑定。如果是则返回 true，反之返回 false。
WithBaseObject()	如果这个环境记录与一个 `with` 语句相关联，那么返回这个 with 对象。否则返回 undefined。

8.1.1.1声明环境记录

每个声明环境记录都与一个包含 variable, constant, let, class, module, import, and/or function 声明的 ES 程序作用域相关联。声明环境记录用于绑定其作用域内通过声明定义的一系列标识符。

对于声明环境记录，具体规范方法的行为被定义在下面的算法中。

8.1.1.1.1HasBinding ( `N` )

声明环境记录的具体环境记录方法 HasBinding 用于简单地判断作为参数的标识符是否是当前记录绑定的标识符之一：

Let envRec be the declarative 环境记录 for which the method was invoked.
If envRec has a binding for the name that is the value of N, return true.
Return false.

8.1.1.1.2CreateMutableBinding ( `N`, `D` )

声明环境记录的具体环境记录方法 CreateMutableBinding 用来创建一个新的且绑定名 N 未被初始化的可变绑定。一个绑定名 N 必须是原来不存在于这个环境记录中的。如果布尔类型的参数 D 的值为 true ，则该绑定在后续操作中可以被删除。

Let envRec be the declarative 环境记录 for which the method was invoked.
Assert: envRec does not already have a binding for N.
Create a mutable binding in envRec for N and record that it is uninitialized. If D is true, record that the newly created binding may be deleted by a subsequent DeleteBinding call.
Return NormalCompletion(empty).

8.1.1.1.3CreateImmutableBinding ( `N`, `S` )

The concrete 环境记录 method CreateImmutableBinding for 声明式环境记录 creates a new immutable binding for the name N that is uninitialized. A binding must not already exist in this 环境记录 for N. If the Boolean argument S has the value true the new binding is marked as a strict binding.

Let envRec be the declarative 环境记录 for which the method was invoked.
Assert: envRec does not already have a binding for N.
Create an immutable binding in envRec for N and record that it is uninitialized. If S is true, record that the newly created binding is a strict binding.
Return NormalCompletion(empty).

8.1.1.1.4InitializeBinding ( `N`, `V` )

The concrete 环境记录 method InitializeBinding for 声明式环境记录 is used to set the bound value of the current binding of the identifier whose name is the value of the argument N to the value of argument V. An uninitialized binding for N must already exist.

Let envRec be the declarative 环境记录 for which the method was invoked.
Assert: envRec must have an uninitialized binding for N.
Set the bound value for N in envRec to V.
Record that the binding for N in envRec has been initialized.
Return NormalCompletion(empty).

8.1.1.1.5SetMutableBinding ( `N`, `V`, `S` )

The concrete 环境记录 method SetMutableBinding for 声明式环境记录 attempts to change the bound value of the current binding of the identifier whose name is the value of the argument N to the value of argument V. A binding for N normally already exists, but in rare cases it may not. If the binding is an immutable binding, a TypeError is thrown if S is true.

Let envRec be the declarative 环境记录 for which the method was invoked.
If envRec does not have a binding for N, then
1. If S is true, 抛出一个 ReferenceError 异常.
2. Perform envRec.CreateMutableBinding(N, true).
3. Perform envRec.InitializeBinding(N, V).
4. Return NormalCompletion(empty).
If the binding for N in envRec is a strict binding, set S to true.
If the binding for N in envRec has not yet been initialized, 抛出一个 ReferenceError 异常.
Else if the binding for N in envRec is a mutable binding, change its bound value to V.
Else,
1. Assert: This is an attempt to change the value of an immutable binding.
2. If S is true, 抛出一个 TypeError 异常.
Return NormalCompletion(empty).

Note

An example of ES 代码 that results in a missing binding at step 2 is:

function f(){eval("var x; x = (delete x, 0);")}

8.1.1.1.6GetBindingValue ( `N`, `S` )

The concrete 环境记录 method GetBindingValue for 声明式环境记录 simply returns the value of its bound identifier whose name is the value of the argument N. If the binding exists but is uninitialized a ReferenceError is thrown, regardless of the value of S.

Let envRec be the declarative 环境记录 for which the method was invoked.
Assert: envRec has a binding for N.
If the binding for N in envRec is an uninitialized binding, 抛出一个 ReferenceError 异常.
Return the value currently bound to N in envRec.

8.1.1.1.7DeleteBinding ( `N` )

The concrete 环境记录 method DeleteBinding for 声明式环境记录 can only delete bindings that have been explicitly designated as being subject to deletion.

Let envRec be the declarative 环境记录 for which the method was invoked.
Assert: envRec has a binding for the name that is the value of N.
If the binding for N in envRec cannot be deleted, return false.
Remove the binding for N from envRec.
Return true.

8.1.1.1.8HasThisBinding ( )

Regular 声明式环境记录 do not provide a this binding.

Return false.

8.1.1.1.9HasSuperBinding ( )

Regular 声明式环境记录 do not provide a super binding.

Return false.

8.1.1.1.10WithBaseObject ( )

声明式环境记录 always return undefined as their WithBaseObject.

Return undefined.

8.1.1.2对象环境记录

每一个对象环境记录都有一个关联的对象，这个对象被称作绑定对象 。对象环境记录将一系列字符串形式的标识符名称直接与其绑定对象的属性名称建立对应关系。不是一个 IdentifierName 形式的字符串的属性键不会在绑定的标识符的集合里。不管该属性的 [[Enumerable]] 特性的值是什么，只要是对象自身的或是继承的属性都会被包含在这个集合里。由于对象的属性可以动态的增减，因此对象环境记录所绑定的标识符集合也会隐匿地变化，这是增减绑定对象的属性而产生的副作用。通过以上描述的副作用而建立的绑定，均被视为可变绑定，即使该绑定对应的属性的 Writable 特性的值为 false。对象环境记录没有不可变绑定。

由 with 语句创建的对象环境记录可以提供它们的绑定对象来作为一个隐式的 this 值以方便在函数调用中使用。这种能力由每个对象环境记录都关联的一个 withEnvironment 布尔值控制。默认情况下，任何一个对象环境记录的withEnvironment 的值为 false。

对象环境记录定义的具体规范方法的行为被描述在以下算法中。

8.1.1.2.1HasBinding ( `N` )

The concrete 环境记录 method HasBinding for 对象环境记录 determines if its associated binding object has a property whose name is the value of the argument N:

Let envRec be the object 环境记录 for which the method was invoked.
Let bindings be the binding object for envRec.
Let foundBinding be ? HasProperty(bindings, N).
If foundBinding is false, return false.
If the withEnvironment flag of envRec is false, return true.
Let unscopables be ? Get(bindings, @@unscopables).
If Type(unscopables) is Object, then
1. Let blocked be ToBoolean(? Get(unscopables, N)).
2. If blocked is true, return false.
Return true.

8.1.1.2.2CreateMutableBinding ( `N`, `D` )

The concrete 环境记录 method CreateMutableBinding for 对象环境记录 creates in an 环境记录's associated binding object a property whose name is the String 值 and initializes it to the value undefined. If Boolean argument D has the value true the new property's [[Configurable]] 特性 is set to true; otherwise it is set to false.

Let envRec be the object 环境记录 for which the method was invoked.
Let bindings be the binding object for envRec.
Return ? DefinePropertyOrThrow(bindings, N, PropertyDescriptor{[[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: D}).

Note

Normally envRec will not have a binding for N but if it does, the 语义 of DefinePropertyOrThrow may result in an existing binding being replaced or shadowed or cause an abrupt completion to be returned.

8.1.1.2.3CreateImmutableBinding ( `N`, `S` )

The concrete 环境记录 method CreateImmutableBinding is never used within this specification in association with 对象环境记录.

8.1.1.2.4InitializeBinding ( `N`, `V` )

The concrete 环境记录 method InitializeBinding for 对象环境记录 is used to set the bound value of the current binding of the identifier whose name is the value of the argument N to the value of argument V. An uninitialized binding for N must already exist.

Let envRec be the object 环境记录 for which the method was invoked.
Assert: envRec must have an uninitialized binding for N.
Record that the binding for N in envRec has been initialized.
Return ? envRec.SetMutableBinding(N, V, false).

Note

在本规范中, all uses of CreateMutableBinding for 对象环境记录 are immediately followed by a call to InitializeBinding for the same name. Hence, implementations do not need to explicitly track the initialization state of individual object 环境记录 bindings.

8.1.1.2.5SetMutableBinding ( `N`, `V`, `S` )

The concrete 环境记录 method SetMutableBinding for 对象环境记录 attempts to set the value of the 环境记录's associated binding object's property whose name is the value of the argument N to the value of argument V. A property named N normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument S.

Let envRec be the object 环境记录 for which the method was invoked.
Let bindings be the binding object for envRec.
Return ? Set(bindings, N, V, S).

8.1.1.2.6GetBindingValue ( `N`, `S` )

The concrete 环境记录 method GetBindingValue for 对象环境记录 returns the value of its associated binding object's property whose name is the String 值 of the argument identifier N. The property should already exist but if it does not the result depends upon the value of the S argument:

Let envRec be the object 环境记录 for which the method was invoked.
Let bindings be the binding object for envRec.
Let value be ? HasProperty(bindings, N).
If value is false, then
1. If S is false, return the value undefined; otherwise 抛出一个 ReferenceError 异常.
Return ? Get(bindings, N).

8.1.1.2.7DeleteBinding ( `N` )

The concrete 环境记录 method DeleteBinding for 对象环境记录 can only delete bindings that correspond to properties of the environment object whose [[Configurable]] 特性 have the value true.

Let envRec be the object 环境记录 for which the method was invoked.
Let bindings be the binding object for envRec.
Return ? bindings.[[Delete]](N).

8.1.1.2.8HasThisBinding ( )

Regular 对象环境记录 do not provide a this binding.

Return false.

8.1.1.2.9HasSuperBinding ( )

Regular 对象环境记录 do not provide a super binding.

Return false.

8.1.1.2.10WithBaseObject ( )

对象环境记录 return undefined as their WithBaseObject unless their withEnvironment flag is true.

Let envRec be the object 环境记录 for which the method was invoked.
If the withEnvironment flag of envRec is true, return the binding object for envRec.
Otherwise, return undefined.

8.1.1.3函数环境记录

函数环境记录是一个用于表示一个函数顶层作用域的声明环境记录，如何这个函数不是一个箭头函数，那么它会提供一个 this 绑定。如何一个函数不是箭头函数且引用了 super，那么它的函数环境记录也会包含这个（在函数内用于执行 super 方法调用）状态。

函数环境记录由一些额外的状态域，见表 15.

表 15: 方法环境记录的额外的域

字段名	Value	Meaning
[[ThisValue]]	Any	This is the this value used for this invocation of the function.
[[ThisBindingStatus]]	`"lexical"` \| `"initialized"` \| `"uninitialized"`	If the value is `"lexical"`, this is an ArrowFunction and does not have a local this value.
[[FunctionObject]]	Object	The 函数对象 whose invocation caused this 环境记录 to be created.
[[HomeObject]]	Object \| undefined	If the associated function has `super` property accesses and is not an ArrowFunction, [[HomeObject]] is the object that the function is bound to as a method. The 默认值 for [[HomeObject]] is undefined.
[[NewTarget]]	Object \| undefined	If this 环境记录 was created by the [[Construct]] 内部方法, [[NewTarget]] is the value of the [[Construct]] `newTarget` parameter. Otherwise, its value is undefined.

函数环境记录 support all of the declarative 环境记录 methods listed in Table 14 and share the same specifications for all of those methods except for HasThisBinding and HasSuperBinding. In addition, 函数环境记录 support the methods listed in Table 16:

Table 16: Additional Methods of 函数环境记录

Method	Purpose
BindThisValue(V)	Set the [[ThisValue]] and record that it has been initialized.
GetThisBinding()	Return the value of this 环境记录's `this` binding. Throws a ReferenceError if the `this` binding has not been initialized.
GetSuperBase()	Return the object that is the base for `super` property accesses bound in this 环境记录. The object is derived from this 环境记录's [[HomeObject]] field. The value undefined indicates that `super` property accesses will produce runtime errors.

The behaviour of the additional concrete specification methods for 函数环境记录 is defined by the following 算法:

8.1.1.3.1BindThisValue ( `V` )

Let envRec be the 函数环境记录 for which the method was invoked.
Assert: envRec.[[ThisBindingStatus]] is not "lexical".
If envRec.[[ThisBindingStatus]] is "initialized", 抛出一个 ReferenceError 异常.
Set envRec.[[ThisValue]] to V.
Set envRec.[[ThisBindingStatus]] to "initialized".
Return V.

8.1.1.3.2HasThisBinding ( )

Let envRec be the 函数环境记录 for which the method was invoked.
If envRec.[[ThisBindingStatus]] is "lexical", return false; otherwise, return true.

8.1.1.3.3HasSuperBinding ( )

Let envRec be the 函数环境记录 for which the method was invoked.
If envRec.[[ThisBindingStatus]] is "lexical", return false.
If envRec.[[HomeObject]] has the value undefined, return false; otherwise, return true.

8.1.1.3.4GetThisBinding ( )

Let envRec be the 函数环境记录 for which the method was invoked.
Assert: envRec.[[ThisBindingStatus]] is not "lexical".
If envRec.[[ThisBindingStatus]] is "uninitialized", 抛出一个 ReferenceError 异常.
Return envRec.[[ThisValue]].

8.1.1.3.5GetSuperBase ( )

Let envRec be the 函数环境记录 for which the method was invoked.
Let home be envRec.[[HomeObject]].
If home has the value undefined, return undefined.
Assert: Type(home) is Object.
Return ? home.[[GetPrototypeOf]]().

8.1.1.4全局环境记录

全局环境记录用来表示最外层的作用域，其可以被所有的 ES 脚本元素（that are processed in a common realm）所共享。全局环境记录提供对内置全局对象（条款 18）、全局对象的属性和对所有发生在一个脚本内的顶层声明(13.2.8, 13.2.10) 的绑定。

全局环境记录逻辑上是一个单独的记录，但它也可以被看做是一个混合成的封装体，一部分是对象环境记录，另一部分是声明环境记录。The object 环境记录 has as its base object the 全局对象 of the associated Realm Record. 这个全局对象的值是由全局环境记录的 GetThisBinding 具体方法返回的。全局环境记录的对象环境记录组件包含所有的内置全局对象（见条款 18）和所有通过包含在全局代码中的 a FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, AsyncGeneratorDeclaration, or VariableStatement 引入的绑定。绑定（所有其他在全局代码中的 ES 声明的）被包含在全局环境记录的声明环境记录组件中。

属性可以直接在一个全局对象上被创建。因此，全局环境记录的对象环境记录组件可以包含通过 FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, AsyncGeneratorDeclaration, or VariableDeclaration 声明来显式地创建的绑定和作为全局对象属性来隐式地创建的绑定。为了确认某个绑定是使用声明来显式地创建的，一个全局环境记录会维护一个使用它的 CreateGlobalVarBinding 和 CreateGlobalFunctionBinding 具体方法绑定的名字列表。

全局环境记录存在额外的域（列在表 17 中）和额外的方法（列在表 18 中）。

表 17: 全局环境记录额外的域

字段名	Value	Meaning
[[ObjectRecord]]	Object 环境记录	Binding object is the 全局对象. It contains global 内置 bindings as well as FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, AsyncGeneratorDeclaration, and VariableDeclaration bindings in global code for the associated realm.
[[GlobalThisValue]]	Object	The value returned by `this` in global scope. Hosts may provide any ES Object value.
[[DeclarativeRecord]]	Declarative 环境记录	Contains bindings for all declarations in global code for the associated realm code except for FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, AsyncGeneratorDeclaration, and VariableDeclaration `bindings`.
[[VarNames]]	List of String	The string names bound by FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, AsyncGeneratorDeclaration, and VariableDeclaration declarations in global code for the associated realm.

表 18: 全局环境记录额外的方法

Method	Purpose
GetThisBinding()	Return the value of this 环境记录's `this` binding.
HasVarDeclaration (N)	Determines if the argument identifier has a binding in this 环境记录 that was created using a VariableDeclaration, FunctionDeclaration, GeneratorDeclaration, AsyncFunctionDeclaration, or AsyncGeneratorDeclaration.
HasLexicalDeclaration (N)	Determines if the argument identifier has a binding in this 环境记录 that was created using a lexical declaration 例如 a LexicalDeclaration or a ClassDeclaration.
HasRestrictedGlobalProperty (N)	Determines if the argument is the name of a 全局对象 property that may not be shadowed by a global lexical binding.
CanDeclareGlobalVar (N)	Determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argument `N`.
CanDeclareGlobalFunction (N)	Determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argument `N`.
CreateGlobalVarBinding(N, D)	Used to create and initialize to undefined a global `var` binding in the [[ObjectRecord]] component of a global 环境记录. The binding will be a mutable binding. The corresponding 全局对象 property will have 特性 values appropriate for a `var`. The String 值 `N` is the bound name. If `D` is true the binding may be deleted. Logically equivalent to CreateMutableBinding followed by a SetMutableBinding but it allows var declarations to receive special treatment.
CreateGlobalFunctionBinding(N, V, D)	Create and initialize a global `function` binding in the [[ObjectRecord]] component of a global 环境记录. The binding will be a mutable binding. The corresponding 全局对象 property will have 特性 values appropriate for a `function`. The String 值 `N` is the bound name. `V` is the initialization value. If the Boolean argument `D` is true the binding may be deleted. Logically equivalent to CreateMutableBinding followed by a SetMutableBinding but it allows 函数声明 to receive special treatment.

The behaviour of the concrete specification methods for 全局环境记录 is defined by the following 算法.

8.1.1.4.1HasBinding ( `N` )

The concrete 环境记录 method HasBinding for 全局环境记录 simply determines if the argument identifier is one of the 标识符 bound by the record:

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, return true.
Let ObjRec be envRec.[[ObjectRecord]].
Return ? ObjRec.HasBinding(N).

8.1.1.4.2CreateMutableBinding ( `N`, `D` )

The concrete 环境记录 method CreateMutableBinding for 全局环境记录 creates a new mutable binding for the name N that is uninitialized. The binding is created in the associated DeclarativeRecord. A binding for N must not already exist in the DeclarativeRecord. If Boolean argument D has the value true the new binding is marked as being subject to deletion.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, 抛出一个 TypeError 异常.
Return DclRec.CreateMutableBinding(N, D).

8.1.1.4.3CreateImmutableBinding ( `N`, `S` )

The concrete 环境记录 method CreateImmutableBinding for 全局环境记录 creates a new immutable binding for the name N that is uninitialized. A binding must not already exist in this 环境记录 for N. If the Boolean argument S has the value true the new binding is marked as a strict binding.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, 抛出一个 TypeError 异常.
Return DclRec.CreateImmutableBinding(N, S).

8.1.1.4.4InitializeBinding ( `N`, `V` )

The concrete 环境记录 method InitializeBinding for 全局环境记录 is used to set the bound value of the current binding of the identifier whose name is the value of the argument N to the value of argument V. An uninitialized binding for N must already exist.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, then
1. Return DclRec.InitializeBinding(N, V).
Assert: If the binding exists, it must be in the object 环境记录.
Let ObjRec be envRec.[[ObjectRecord]].
Return ? ObjRec.InitializeBinding(N, V).

8.1.1.4.5SetMutableBinding ( `N`, `V`, `S` )

The concrete 环境记录 method SetMutableBinding for 全局环境记录 attempts to change the bound value of the current binding of the identifier whose name is the value of the argument N to the value of argument V. If the binding is an immutable binding, a TypeError is thrown if S is true. A property named N normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument S.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, then
1. Return DclRec.SetMutableBinding(N, V, S).
Let ObjRec be envRec.[[ObjectRecord]].
Return ? ObjRec.SetMutableBinding(N, V, S).

8.1.1.4.6GetBindingValue ( `N`, `S` )

The concrete 环境记录 method GetBindingValue for 全局环境记录 returns the value of its bound identifier whose name is the value of the argument N. If the binding is an uninitialized binding 抛出一个 ReferenceError 异常. A property named N normally already exists but if it does not or is not currently writable, error handling is determined by the value of the Boolean argument S.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, then
1. Return DclRec.GetBindingValue(N, S).
Let ObjRec be envRec.[[ObjectRecord]].
Return ? ObjRec.GetBindingValue(N, S).

8.1.1.4.7DeleteBinding ( `N` )

The concrete 环境记录 method DeleteBinding for 全局环境记录 can only delete bindings that have been explicitly designated as being subject to deletion.

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
If DclRec.HasBinding(N) is true, then
1. Return DclRec.DeleteBinding(N).
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let existingProp be ? HasOwnProperty(globalObject, N).
If existingProp is true, then
1. Let status be ? ObjRec.DeleteBinding(N).
2. If status is true, then
  1. Let varNames be envRec.[[VarNames]].
  2. If N is an element of varNames, remove that element from the varNames.
3. Return status.
Return true.

8.1.1.4.8HasThisBinding ( )

Return true.

8.1.1.4.9HasSuperBinding ( )

Return false.

8.1.1.4.10WithBaseObject ( )

全局环境记录 always return undefined as their WithBaseObject.

Return undefined.

8.1.1.4.11GetThisBinding ( )

Let envRec be the global 环境记录 for which the method was invoked.
Return envRec.[[GlobalThisValue]].

8.1.1.4.12HasVarDeclaration ( `N` )

The concrete 环境记录 method HasVarDeclaration for 全局环境记录 determines if the argument identifier has a binding in this record that was created using a VariableStatement or a FunctionDeclaration:

Let envRec be the global 环境记录 for which the method was invoked.
Let varDeclaredNames be envRec.[[VarNames]].
If varDeclaredNames contains N, return true.
Return false.

8.1.1.4.13HasLexicalDeclaration ( `N` )

The concrete 环境记录 method HasLexicalDeclaration for 全局环境记录 determines if the argument identifier has a binding in this record that was created using a lexical declaration 例如 a LexicalDeclaration or a ClassDeclaration:

Let envRec be the global 环境记录 for which the method was invoked.
Let DclRec be envRec.[[DeclarativeRecord]].
Return DclRec.HasBinding(N).

8.1.1.4.14HasRestrictedGlobalProperty ( `N` )

The concrete 环境记录 method HasRestrictedGlobalProperty for 全局环境记录 determines if the argument identifier is the name of a property of the 全局对象 that must not be shadowed by a global lexical binding:

Let envRec be the global 环境记录 for which the method was invoked.
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let existingProp be ? globalObject.[[GetOwnProperty]](N).
If existingProp is undefined, return false.
If existingProp.[[Configurable]] is true, return false.
Return true.

Note

Properties may exist upon a 全局对象 that were directly created rather than being declared using a var or function declaration. A global lexical binding may not be created that has the same name as a non-configurable property of the 全局对象. The global property undefined is an example of such a property.

8.1.1.4.15CanDeclareGlobalVar ( `N` )

The concrete 环境记录 method CanDeclareGlobalVar for 全局环境记录 determines if a corresponding CreateGlobalVarBinding call would succeed if called for the same argument N. Redundant var declarations and var declarations for pre-existing 全局对象 properties are allowed.

Let envRec be the global 环境记录 for which the method was invoked.
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let hasProperty be ? HasOwnProperty(globalObject, N).
If hasProperty is true, return true.
Return ? IsExtensible(globalObject).

8.1.1.4.16CanDeclareGlobalFunction ( `N` )

The concrete 环境记录 method CanDeclareGlobalFunction for 全局环境记录 determines if a corresponding CreateGlobalFunctionBinding call would succeed if called for the same argument N.

Let envRec be the global 环境记录 for which the method was invoked.
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let existingProp be ? globalObject.[[GetOwnProperty]](N).
If existingProp is undefined, return ? IsExtensible(globalObject).
If existingProp.[[Configurable]] is true, return true.
If IsDataDescriptor(existingProp) is true and existingProp has 特性 values {[[Writable]]: true, [[Enumerable]]: true}, return true.
Return false.

8.1.1.4.17CreateGlobalVarBinding ( `N`, `D` )

The concrete 环境记录 method CreateGlobalVarBinding for 全局环境记录 creates and initializes a mutable binding in the associated object 环境记录 and records the bound name in the associated [[VarNames]] List. If a binding already exists, it is reused and assumed to be initialized.

Let envRec be the global 环境记录 for which the method was invoked.
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let hasProperty be ? HasOwnProperty(globalObject, N).
Let extensible be ? IsExtensible(globalObject).
If hasProperty is false and extensible is true, then
1. Perform ? ObjRec.CreateMutableBinding(N, D).
2. Perform ? ObjRec.InitializeBinding(N, undefined).
Let varDeclaredNames be envRec.[[VarNames]].
If varDeclaredNames does not contain N, then
1. Append N to varDeclaredNames.
Return NormalCompletion(empty).

8.1.1.4.18CreateGlobalFunctionBinding ( `N`, `V`, `D` )

The concrete 环境记录 method CreateGlobalFunctionBinding for 全局环境记录 creates and initializes a mutable binding in the associated object 环境记录 and records the bound name in the associated [[VarNames]] List. If a binding already exists, it is replaced.

Let envRec be the global 环境记录 for which the method was invoked.
Let ObjRec be envRec.[[ObjectRecord]].
Let globalObject be the binding object for ObjRec.
Let existingProp be ? globalObject.[[GetOwnProperty]](N).
If existingProp is undefined or existingProp.[[Configurable]] is true, then
1. Let desc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: D}.
Else,
1. Let desc be the PropertyDescriptor{[[Value]]: V }.
Perform ? DefinePropertyOrThrow(globalObject, N, desc).
Record that the binding for N in ObjRec has been initialized.
Perform ? Set(globalObject, N, V, false).
Let varDeclaredNames be envRec.[[VarNames]].
If varDeclaredNames does not contain N, then
1. Append N to varDeclaredNames.
Return NormalCompletion(empty).

Note

Global 函数声明 are always represented as 自身属性 of the 全局对象. If possible, an existing 自身属性 is reconfigured to have a standard set of 特性 values. Steps 8-9 are equivalent to what calling the InitializeBinding concrete method would do and if globalObject is a Proxy will produce the same sequence of Proxy trap calls.

8.1.1.5模块环境记录

模块环境记录是一个声明环境记录，用于表示一个 ES 模块的外层作用域。除了正常的可变和不可变的绑定之外，模块环境记录还提供不可变的 import 绑定（可以提供对一个存在于另一个环境记录的目标绑定的间接访问）。

模块环境记录支持所有声明环境记录的方法（见表 14）和共享除了 GetBindingValue, DeleteBinding, HasThisBinding and GetThisBinding 这些的所有方法的相同规范。另外，模块环境记录支持列在表 19 中的方法：

表 19: 模块环境记录的额外方法

Method	Purpose
CreateImportBinding(N, M, N2)	Create an immutable indirect binding in a module 环境记录. The String 值 `N` is the text of the bound name. `M` is a Module Record, and `N2` is a binding that exists in M's module 环境记录.
GetThisBinding()	Return the value of this 环境记录's `this` binding.

The behaviour of the additional concrete specification methods for 模块环境记录 are defined by the following 算法:

8.1.1.5.1GetBindingValue ( `N`, `S` )

The concrete 环境记录 method GetBindingValue for 模块环境记录 returns the value of its bound identifier whose name is the value of the argument N. However, if the binding is an indirect binding the value of the target binding is returned. If the binding exists but is uninitialized a ReferenceError is thrown.

Assert: S is true.
Let envRec be the module 环境记录 for which the method was invoked.
Assert: envRec has a binding for N.
If the binding for N is an indirect binding, then
1. Let M and N2 be the indirection values provided when this binding for N was created.
2. Let targetEnv be M.[[Environment]].
3. If targetEnv is undefined, 抛出一个 ReferenceError 异常.
4. Let targetER be targetEnv's EnvironmentRecord.
5. Return ? targetER.GetBindingValue(N2, true).
If the binding for N in envRec is an uninitialized binding, 抛出一个 ReferenceError 异常.
Return the value currently bound to N in envRec.

Note

S will always be true because a Module is always 严格模式代码.

8.1.1.5.2DeleteBinding ( `N` )

The concrete 环境记录 method DeleteBinding for 模块环境记录 refuses to delete bindings.

Assert: This method is never invoked. See 12.5.3.1.

Note

模块环境记录 are only used within strict code and an 早期错误 rule prevents the delete 运算符, in strict code, from being applied to a Reference that would resolve to a module 环境记录 binding. See 12.5.3.1.

8.1.1.5.3HasThisBinding ( )

模块环境记录 provide a this binding.

Return true.

8.1.1.5.4GetThisBinding ( )

Return undefined.

8.1.1.5.5CreateImportBinding ( `N`, `M`, `N2` )

The concrete 环境记录 method CreateImportBinding for 模块环境记录 creates a new initialized immutable indirect binding for the name N. A binding must not already exist in this 环境记录 for N. M is a Module Record, and N2 is the name of a binding that exists in M's module 环境记录. Accesses to the value of the new binding will indirectly access the bound value of the target binding.

Let envRec be the module 环境记录 for which the method was invoked.
Assert: envRec does not already have a binding for N.
Assert: M is a Module Record.
Assert: When M.[[Environment]] is instantiated it will have a direct binding for N2.
Create an immutable indirect binding in envRec for N that references M and N2 as its target binding and record that the binding is initialized.
Return NormalCompletion(empty).

8.1.2词法环境操作

在本规范中，以下抽象操作被用于操作词法环境：

8.1.2.1GetIdentifierReference ( `lex`, `name`, `strict` )

The 抽象操作 GetIdentifierReference is called with a 词法环境 lex, a String name, and a Boolean flag strict. The value of lex may be null. When called, the following steps are performed:

If lex is the value null, then
1. Return a value of type Reference whose base value component is undefined, whose referenced name component is name, and whose strict reference flag is strict.
Let envRec be lex's EnvironmentRecord.
Let exists be ? envRec.HasBinding(name).
If exists is true, then
1. Return a value of type Reference whose base value component is envRec, whose referenced name component is name, and whose strict reference flag is strict.
Else,
1. Let outer be the value of lex's outer environment reference.
2. Return ? GetIdentifierReference(outer, name, strict).

8.1.2.2NewDeclarativeEnvironment ( `E` )

When the 抽象操作 NewDeclarativeEnvironment is called with a 词法环境 as argument E the following steps are performed:

Let env be a new 词法环境.
Let envRec be a new declarative 环境记录 containing no bindings.
Set env's EnvironmentRecord to envRec.
Set the outer 词法环境 reference of env to E.
Return env.

8.1.2.3NewObjectEnvironment ( `O`, `E` )

When the 抽象操作 NewObjectEnvironment is called with an Object O and a 词法环境 E as arguments, the following steps are performed:

Let env be a new 词法环境.
Let envRec be a new object 环境记录 containing O as the binding object.
Set env's EnvironmentRecord to envRec.
Set the outer 词法环境 reference of env to E.
Return env.

8.1.2.4NewFunctionEnvironment ( `F`, `newTarget` )

When the 抽象操作 NewFunctionEnvironment is called with arguments F and newTarget the following steps are performed:

Assert: F is an ES function.
Assert: Type(newTarget) is Undefined or Object.
Let env be a new 词法环境.
Let envRec be a new 函数环境记录 containing no bindings.
Set envRec.[[FunctionObject]] to F.
If F.[[ThisMode]] is lexical, set envRec.[[ThisBindingStatus]] to "lexical".
Else, set envRec.[[ThisBindingStatus]] to "uninitialized".
Let home be F.[[HomeObject]].
Set envRec.[[HomeObject]] to home.
Set envRec.[[NewTarget]] to newTarget.
Set env's EnvironmentRecord to envRec.
Set the outer 词法环境 reference of env to F.[[Environment]].
Return env.

8.1.2.5NewGlobalEnvironment ( `G`, `thisValue` )

When the 抽象操作 NewGlobalEnvironment is called with arguments G and thisValue, the following steps are performed:

Let env be a new 词法环境.
Let objRec be a new object 环境记录 containing G as the binding object.
Let dclRec be a new declarative 环境记录 containing no bindings.
Let globalRec be a new global 环境记录.
Set globalRec.[[ObjectRecord]] to objRec.
Set globalRec.[[GlobalThisValue]] to thisValue.
Set globalRec.[[DeclarativeRecord]] to dclRec.
Set globalRec.[[VarNames]] to a new empty List.
Set env's EnvironmentRecord to globalRec.
Set the outer 词法环境 reference of env to null.
Return env.

8.1.2.6NewModuleEnvironment ( `E` )

When the 抽象操作 NewModuleEnvironment is called with a 词法环境 argument E the following steps are performed:

Let env be a new 词法环境.
Let envRec be a new module 环境记录 containing no bindings.
Set env's EnvironmentRecord to envRec.
Set the outer 词法环境 reference of env to E.
Return env.

8.2范围

Before it is evaluated, 所有的 ES 代码都必须与一个范围相关联。概念上，一个范围是由一套内部对象、一个 ES 全局环境、在全局环境的作用域中加载的所有 ES 代码，和其它相关联的状态和资源构成。

在本规范中，范围被表示为一个携带以下域（由表 20 指定）的范围记录：

表 20: 范围记录域

字段名	Value	Meaning
[[Intrinsics]]	Record whose field names are intrinsic keys and whose values are objects	The intrinsic values used by code associated with this realm
[[GlobalObject]]	Object	The 全局对象 for this realm
[[GlobalEnv]]	词法环境	The 全局环境 for this realm
[[TemplateMap]]	A List of Record { [[Site]]: 解析节点, [[Array]]: Object}.	Template objects are canonicalized separately for each realm using its Realm Record's [[TemplateMap]]. Each [[Site]] value is a 解析节点 that is a TemplateLiteral. The associated [[Array]] value is the corresponding template object that is passed to a tag function. Note Once a 解析节点 becomes unreachable, the corresponding [[Array]] is also unreachable, and it would be unobservable if an 实现 removed the pair from the [[TemplateMap]] list.
[[HostDefined]]	Any, 默认值 is undefined.	Field reserved for use by 宿主环境 that need to associate additional information with a Realm Record.

8.2.1CreateRealm ( )

The 抽象操作 CreateRealm with no arguments 执行如下:

Let realmRec be a new Realm Record.
Perform CreateIntrinsics(realmRec).
Set realmRec.[[GlobalObject]] to undefined.
Set realmRec.[[GlobalEnv]] to undefined.
Set realmRec.[[TemplateMap]] to a new empty List.
Return realmRec.

8.2.2CreateIntrinsics ( `realmRec` )

The 抽象操作 CreateIntrinsics with argument realmRec 执行如下:

Let intrinsics be a new Record.
Set realmRec.[[Intrinsics]] to intrinsics.
Let objProto be ObjectCreate(null).
Set intrinsics.[[%ObjectPrototype%]] to objProto.
Let throwerSteps be the 算法步骤 specified in 9.2.8.1 for the %ThrowTypeError% function.
Let thrower be CreateBuiltinFunction(throwerSteps, « », realmRec, null).
Set intrinsics.[[%ThrowTypeError%]] to thrower.
Let noSteps be an empty sequence of 算法步骤.
Let funcProto be CreateBuiltinFunction(noSteps, « », realmRec, objProto).
Set intrinsics.[[%FunctionPrototype%]] to funcProto.
Call thrower.[[SetPrototypeOf]](funcProto).
Perform AddRestrictedFunctionProperties(funcProto, realmRec).
Set fields of intrinsics with the values listed in Table 7 that have not already been handled above. The field names are the names listed in column one of the table. The value of each field is a new object value fully and recursively populated with property values as defined by the specification of each object in clauses 18-26. All object property values are newly created object values. All values that are 内置函数对象 are created by performing CreateBuiltinFunction(<steps>, <slots>, realmRec, <prototype>) where <steps> is the definition of that function provided by this specification, <slots> is a list of the names, if any, of the function's specified 内部属性, and <prototype> is the specified value of the function's [[Prototype]] 内部属性. The creation of the intrinsics and their properties must be ordered to avoid any dependencies upon objects that have not yet been created.
Return intrinsics.

8.2.3SetRealmGlobalObject ( `realmRec`, `globalObj`, `thisValue` )

The 抽象操作 SetRealmGlobalObject with arguments realmRec, globalObj, and thisValue 执行如下:

If globalObj is undefined, then
1. Let intrinsics be realmRec.[[Intrinsics]].
2. Set globalObj to ObjectCreate(intrinsics.[[%ObjectPrototype%]]).
Assert: Type(globalObj) is Object.
If thisValue is undefined, set thisValue to globalObj.
Set realmRec.[[GlobalObject]] to globalObj.
Let newGlobalEnv be NewGlobalEnvironment(globalObj, thisValue).
Set realmRec.[[GlobalEnv]] to newGlobalEnv.
Return realmRec.

8.2.4SetDefaultGlobalBindings ( `realmRec` )

The 抽象操作 SetDefaultGlobalBindings with argument realmRec 执行如下:

Let global be realmRec.[[GlobalObject]].
For each property of 全局对象 specified in clause 18, do
1. Let name be the String 值 of the 属性名.
2. Let desc be the fully populated 数据属性 descriptor for the property containing the specified 特性 for the property. For properties listed in 18.2, 18.3, or 18.4 the value of the [[Value]] 特性 is the corresponding 内部对象 from realmRec.
3. Perform ? DefinePropertyOrThrow(global, name, desc).
Return global.

8.3执行上下文

执行上下文是一个规范设备，被一个 ES 实现用来追踪代码的运行时评估。在任何的时间点，每一个代理（实际上是正在执行的代码）最多只能存在一个执行上下文，被称为代理的运行时执行上下文。在本规范中，对运行时执行上下文的所有引用都是指周围代理的运行时执行上下文。

执行上下文堆栈用来追中执行上下文。运行时执行上下文总是这个堆栈的头元素。每当控制从与当前运行时执行上下文相关联的可执行代码被转移到另外一个没有与那个执行上下文相关联的可执行代码时，一个新的执行上下文会被创建。新的被创建的执行上下文会被 push 到这个堆栈的头部，并成为运行时执行上下文。

无论实现指定的状态是什么，一个执行上下文（无论是否有必要去追踪与它相关联的代码的执行进度）应该包含实现指定的状态。每个执行上下文都至少有以下状态（列在表 21 中）：

表 21: 所有执行上下文的状态组件

Component	Purpose
code 估值 state	Any state needed to perform, suspend, and resume 估值 of the code associated with this 执行上下文.
Function	If this 执行上下文 is evaluating the code of a 函数对象, then the value of this component is that 函数对象. If the context is evaluating the code of a Script or Module, the value is null.
Realm	The Realm Record from which associated code accesses ES resources.
ScriptOrModule	The Module Record or 脚本记录 from which associated code originates. If there is no originating script or module, as is the case for the original 执行上下文 created in InitializeHostDefinedRealm, the value is null.

运行时执行上下文对代码的评估可以在该规范中定义的各个点上暂停。一旦运行时执行上下文被暂停，一个不同的执行上下文就可能成为运行时执行上下文，并开始评估其代码。在稍后的时间内，一个被暂停的执行上下文可能再次成为运行时执行上下文，并继续在其先前暂停的位置上对其执行代码进行评估。在执行上下文中运行时执行上下文状态的转换通常以类似于后进先出的方式出现在堆栈中。然而，一些 ES 功能需要运行时执行上下文非后进先出的过渡。

运行时执行上下文的范围组件的值也被称为当前范围记录。运行时执行上下文的函数组件的值也被称为活动函数对象。

ES 代码的执行上下文存在以下附加状态组件（列在表 22 中）。

表 22: ES 代码执行上下文的附加状态组件

Component	Purpose
LexicalEnvironment	标识用于解析此执行上下文中代码所做的标识符引用的词法环境。
VariableEnvironment	标识此词法环境内通过 VariableStatements 创建的词法环境的绑定。

一个执行上下文的 LexicalEnvironment 和 VariableEnvironment 组件都是词法环境。

表示生成器对象评价的执行上下文具有表 23 中列出的其他状态组件。

表 23: 生成器执行上下文的附加状态组件

Component	Purpose
Generator	The GeneratorObject that this 执行上下文 is evaluating.

在大多数情况下，只有运行时执行上下文（执行上下文堆栈的顶部）是被本规范中的算法所直接操作的。 Hence when the terms “LexicalEnvironment”, and “VariableEnvironment” are used without qualification they are in reference to those components of the 运行时执行上下文.

An 执行上下文 is purely a specification mechanism and need not correspond to any particular artefact of an ES 实现. It is impossible for ES 代码 to directly access or observe an 执行上下文.执行上下文是一个纯粹的规范机制，不需要对应于任何 ES 实现指定的 artefact。对于 ES 代码来说，直接访问或观察一个执行上下文是不可能的。

8.3.1GetActiveScriptOrModule ( )

The GetActiveScriptOrModule 抽象操作 is used to determine the running script or module, based on the 运行时执行上下文. GetActiveScriptOrModule 执行如下:

If the 执行上下文堆栈 is empty, return null.
Let ec be the topmost 执行上下文 on the 执行上下文堆栈 whose ScriptOrModule component is not null.
If no such 执行上下文 exists, return null. Otherwise, return ec's ScriptOrModule component.

8.3.2ResolveBinding ( `name` [ , `env` ] )

The ResolveBinding 抽象操作 is used to determine the binding of name passed as a String 值. The 可选参数 env can be used to explicitly provide the 词法环境 that is to be searched for the binding. During execution of ES 代码, ResolveBinding is performed using the following 算法:

If env is not present or if env is undefined, then
1. Set env to the 运行时执行上下文's LexicalEnvironment.
Assert: env is a 词法环境.
If the code matching the syntactic production that is being evaluated is contained in 严格模式代码, let strict be true, else let strict be false.
Return ? GetIdentifierReference(env, name, strict).

Note

The result of ResolveBinding is always a Reference value with its referenced name component equal to the name argument.

8.3.3GetThisEnvironment ( )

The 抽象操作 GetThisEnvironment finds the 环境记录 that currently supplies the binding of the keyword this. GetThisEnvironment 执行如下:

Let lex be the 运行时执行上下文's LexicalEnvironment.
Repeat,
1. Let envRec be lex's EnvironmentRecord.
2. Let exists be envRec.HasThisBinding().
3. If exists is true, return envRec.
4. Let outer be the value of lex's outer environment reference.
5. Assert: outer is not null.
6. Set lex to outer.

Note

The loop in step 2 will always terminate because the list of environments always ends with the 全局环境 which has a this binding.

8.3.4ResolveThisBinding ( )

The 抽象操作 ResolveThisBinding determines the binding of the keyword this using the LexicalEnvironment of the 运行时执行上下文. ResolveThisBinding 执行如下:

Let envRec be GetThisEnvironment( ).
Return ? envRec.GetThisBinding().

8.3.5GetNewTarget ( )

The 抽象操作 GetNewTarget determines the NewTarget value using the LexicalEnvironment of the 运行时执行上下文. GetNewTarget 执行如下:

Let envRec be GetThisEnvironment( ).
Assert: envRec has a [[NewTarget]] field.
Return envRec.[[NewTarget]].

8.3.6GetGlobalObject ( )

The 抽象操作 GetGlobalObject returns the 全局对象 used by the currently 运行时执行上下文. GetGlobalObject 执行如下:

Let ctx be the 运行时执行上下文.
Let currentRealm be ctx's Realm.
Return currentRealm.[[GlobalObject]].

8.4作业和作业队列

当在当前的进度中没有其它 ES 计算时，Job 是一个用来初始化一个 ES 计算的抽象操作。可以定义 Job 抽象操作以接受任意一组作业参数。

A Pending Job is an internal Record whose fields are specified in Table. Once execution of a Job is initiated, the Job always executes to completion. No other Job may be initiated until the currently running Job completes. However, the currently running Job or external events may cause the enqueuing of additional Pending Jobs that may be initiated sometime after completion of the currently running Job.只有在没有运行时执行上下文和执行上下文堆栈是空的情况下才能启动一个 Job 的执行。一个暂停的 Job 是一个 Job 的未来执行请求。暂停的 Job 是一个内部记录，其字段在表 24 中指定。一旦开始执行一个 Job，Job 会始终执行直到完成。在当前运行的 Job 完成之前，不可以启动其他 Job。然而，当前正在运行的 Job 或外部事件可能会导致额外的暂停的 Job（可能是当前正在运行的 Job 完成后的某个时候开始执行）入队。

表 24: 暂停的 Job 记录字段

字段名	Value	Meaning
[[Job]]	The name of a Job 抽象操作	This is the 抽象操作 that is performed when execution of this Pending Job is initiated.
[[Arguments]]	A List	The List of argument values that are to be passed to [[Job]] when it is activated.
[[Realm]]	A Realm Record	The Realm Record for the initial 执行上下文 when this PendingJob is initiated.
[[ScriptOrModule]]	A 脚本记录 or Module Record	The script or module for the initial 执行上下文 when this PendingJob is initiated.
[[HostDefined]]	Any, 默认值 is undefined.	Field reserved for use by 宿主环境 that need to associate additional information with a pending Job.

Job 队列是一个暂停 Job 记录的 FIFO（先进先出）队列。每个 Job 队列都有一个名字和全套的可用的 Job 队列（由 ES 实现定义）。每个 ES 实现至少有在表 25 中定义的 Job 队列。

每个代理都有自己的一组命名 Job 队列。本规范中对命名 Job 队列的所有引用都表示周围代理的命名 Job 队列。

表 25: 必须的 Job 队列

Name	Purpose
ScriptJobs	Jobs that validate and evaluate ES Script and Module 源文本. See clauses 10 and 15.
PromiseJobs	Jobs that are responses to the settlement of a Promise (see 25.6).

一个 Job 的将来执行请求会通过入队实现，一个 Job 队列，一个 PendingJob 记录（包括 Job 抽象操作名和必要的参数值）。当没有运行时执行上下文和执行上下文堆栈为空时，ES 实现会从 Job 队列中移除第一个 PendingJob 和使用包含在它里面的信息来创建一个执行上下文和开始执行相关 Job 抽象操作。

来自一个简单的 Job 队列中的 PendingJob 记录总是会以一种 FIFO 的顺序开始。本规范没有定义多 Job 队列的顺序是如何服务的。一个 ES 实现或许会交替的实现一个 Job 队列的 PendingJob 记录的 FIFO 评估和另外一个或多个 Job 队列的 PendingJob 的评估。一个实现必须定义当没有运行时执行上下文和所有 Job 队列为空时会发生什么。

Note

一个典型的 ES 实现会有它的 Job 队列，即至少有一个 PendingJob 会被预初始化和这些 Jobs 中的其中一个将会是第一个被执行。如果当前 Job 已完成且所有 Job 队列都为空，则实现可能选择释放所有资源并终止。或者，它可能会选择等待一些具体实现的代理或机制将新 PendingJob 请求入队。

以下抽象操作被用来创建和管理 Jobs 和 Job Queues：

8.4.1EnqueueJob ( `queueName`, `job`, `arguments` )

The EnqueueJob 抽象操作 requires three arguments: queueName, job, and arguments. It 执行如下:

Assert: Type(queueName) is String and its value is the name of a Job Queue recognized by this 实现.
Assert: job is the name of a Job.
Assert: arguments is a List that has the same number of elements as the number of parameters required by job.
Let callerContext be the 运行时执行上下文.
Let callerRealm be callerContext's Realm.
Let callerScriptOrModule be callerContext's ScriptOrModule.
Let pending be PendingJob{ [[Job]]: job, [[Arguments]]: arguments, [[Realm]]: callerRealm, [[ScriptOrModule]]: callerScriptOrModule, [[HostDefined]]: undefined }.
Perform any 实现 or host environment defined processing of pending. This may include modifying the [[HostDefined]] field or any other field of pending.
Add pending at the back of the Job Queue named by queueName.
Return NormalCompletion(empty).

8.5InitializeHostDefinedRealm ( )

抽象操作 InitializeHostDefinedRealm 会执行以下步骤：

Let realm be CreateRealm().
Let newContext be a new 执行上下文.
Set the Function of newContext to null.
Set the Realm of newContext to realm.
Set the ScriptOrModule of newContext to null.
Push newContext onto the 执行上下文堆栈; newContext is now the 运行时执行上下文.
If the host requires use of an 外来对象 to serve as realm's 全局对象, let global be such an object created in an 实现-defined manner. Otherwise, let global be undefined, indicating that an 普通对象 should be created as the 全局对象.
If the host requires that the this binding in realm's global scope return an object other than the 全局对象, let thisValue be such an object created in an 实现-defined manner. Otherwise, let thisValue be undefined, indicating that realm's global this binding should be the 全局对象.
Perform SetRealmGlobalObject(realm, global, thisValue).
Let globalObj be ? SetDefaultGlobalBindings(realm).
Create any 实现-defined 全局对象 properties on globalObj.
Return NormalCompletion(empty).

8.6RunJobs ( )

抽象操作 RunJobs 会执行以下步骤：

Perform ? InitializeHostDefinedRealm().
In an 实现-dependent manner, obtain the ES source texts (see clause 10) and any associated host-defined values for zero or more ES 脚本 and/or ES 模块. For each such 源文本 and hostDefined, do
1. If 源文本 is the source code of a script, then
  1. Perform EnqueueJob("ScriptJobs", ScriptEvaluationJob, « 源文本, hostDefined »).
2. Else 源文本 is the source code of a module,
  1. Perform EnqueueJob("ScriptJobs", TopLevelModuleEvaluationJob, « 源文本, hostDefined »).
Repeat,
1. Suspend the 运行时执行上下文 and remove it from the 执行上下文堆栈.
2. Assert: The 执行上下文堆栈 is now empty.
3. Let nextQueue be a non-empty Job Queue chosen in an 实现-defined manner. If all Job Queues are empty, the result is 实现-defined.
4. Let nextPending be the PendingJob record at the front of nextQueue. Remove that record from nextQueue.
5. Let newContext be a new 执行上下文.
6. Set newContext's Function to null.
7. Set newContext's Realm to nextPending.[[Realm]].
8. Set newContext's ScriptOrModule to nextPending.[[ScriptOrModule]].
9. Push newContext onto the 执行上下文堆栈; newContext is now the 运行时执行上下文.
10. Perform any 实现 or host environment defined job initialization using nextPending.
11. Let result be the result of performing the 抽象操作 named by nextPending.[[Job]] using the elements of nextPending.[[Arguments]] as its arguments.
12. If result is an abrupt completion, perform HostReportErrors(« result.[[Value]] »).

8.7代理

代理包括一套 ES 的执行上下文，一个执行上下文堆栈，一个运行时执行上下文，一组命名的 Job 队列，一个代理记录，和一个执行线程。除执行线程外，代理的组成部分完全属于该代理。

An agent's executing thread executes the jobs in the agent's job queues on the agent's 执行上下文 independently of other 代理, except that an executing thread may be used as the executing thread by multiple 代理, provided none of the 代理 sharing the thread have an Agent Record whose [[CanBlock]] property is true.

Note 1

例如，有些 web 浏览器会在一个浏览器窗口的多个不相关的选项卡上共享一个单独的执行线程。

当代理的执行线程执行代理的作业队列中的作业时，代理是这些工作中的代码的周围代理。代码使用周围代理来访问代理中保存的规范级执行对象：运行时执行上下文、执行上下文堆栈、命名的作业队列和代理记录的字段。

Table 26: Agent Record Fields

字段名	Value	Meaning
[[LittleEndian]]	Boolean	The 默认值 computed for the isLittleEndian parameter when it is needed by the 算法 GetValueFromBuffer and SetValueInBuffer. The choice is 实现-dependent and should be the alternative that is most efficient for the 实现. Once the value has been observed it cannot change.
[[CanBlock]]	Boolean	Determines whether the agent can block or not.
[[Signifier]]	Any globally-unique value	Uniquely identifies the agent within its agent cluster.
[[IsLockFree1]]	Boolean	true if atomic operations on one-byte values are lock-free, false otherwise.
[[IsLockFree2]]	Boolean	true if atomic operations on two-byte values are lock-free, false otherwise.
[[CandidateExecution]]	A candidate execution Record	See the 内存模型.

Once the values of [[Signifier]], [[IsLockFree1]], and [[IsLockFree2]] have been observed by any agent in the agent cluster they cannot change.

Note 2

The values of [[IsLockFree1]] and [[IsLockFree2]] are not necessarily determined by the hardware, but may also reflect 实现 choices that can vary over time and between ES implementations.

There is no [[IsLockFree4]] property: 4-byte atomic operations are always lock-free.

In practice, if an atomic operation is implemented with any type of lock the operation is not lock-free. Lock-free does not imply wait-free: there is no upper bound on how many machine steps may be required to complete a lock-free atomic operation.

That an atomic access of size n is lock-free does not imply anything about the (perceived) atomicity of non-atomic accesses of size n, specifically, non-atomic accesses may still be performed as a sequence of several separate memory accesses. See ReadSharedMemory and WriteSharedMemory for details.

Note 3

An agent is a specification mechanism and need not correspond to any particular artefact of an ES 实现.

8.7.1AgentSignifier( )

The 抽象操作 AgentSignifier takes no arguments. It 执行如下:

Let AR be the Agent Record of the surrounding agent.
Return AR.[[Signifier]].

8.7.2AgentCanSuspend( )

The 抽象操作 AgentCanSuspend takes no arguments. It 执行如下:

Let AR be the Agent Record of the surrounding agent.
Return AR.[[CanBlock]].

Note

In some environments it may not be reasonable for a given agent to suspend. 例如, in a web browser environment, it may be reasonable to disallow suspending a document's main event handling thread, while still allowing workers' event handling threads to suspend.

8.8代理集群

代理集群是通过共享内存操作进行通信的最大代理集。

Note 1

不同代理中的程序可能以未指定的方式共享内存。至少，SharedArrayBuffer 对象的后备存储器可以在集群的代理之间共享。

通过消息传递来通信的代理不能共享内存；它们从不在同一个代理集群中。

每个代理精确地属于一个代理集群。

Note 2

集群中的代理并不需要在一些特定的时间点都是活跃的。如果代理 A 创建了另一个代理 B，然后 A 终止，B 创建代理 C，如果 A 可以与 B 共享一些内存，且 B 可以和 C 共享一些内存，那么三个代理在同一个集群中。

在一个集群内的所有代理对于属性 [[LittleEndian]]，在它们各自的代理记录中都必须有相同的值。

Note 3

如果在一个代理集群中不同的代理对属性 [[LittleEndian] 有不同的值，那么使用共享内存的多字节数据会变得很难。

一个集群中的所有代理对于属性 [[IsLockFree1]]，在它们各自的代理记录中都必须有相同的值；[[IsLockFree2]] 属性也类似。

一个集群中的所有代理对于属性 [[Signifier]]，在它们各自的代理记录中都必须有不同的值。

嵌入可以禁用（停止前进进程）或激活（恢复前进进程）一个代理，而无需代理的知识或合作。如果嵌入这样做，它就不能在集群中的其他代理被无限期停用时将一些代理留在集群中。

Note 4

上述限制的目的是为了避免因一个代理被停用而导致另一个代理死锁或饿死的现象。例如，如果一个在任何窗口中对文档有一个终生的依赖的 HTML 共享工人，被允许和这样一个依赖文档的敬业工人一起共享内存，当敬业的工人持有一个锁（例如，文档被推到窗口的历史中）时，文档和它的敬业的工人都将会被停用，并且如果之后共享的工人尝试去获取该锁，那么共享的工人将被锁直到敬业工人被再次激活。与此同时，其他试图从其他窗口访问共享工人的工人也将挨饿。

这种限制的含义是，在嵌入中不属于同一挂起/唤醒组的代理之间不可能共享内存。

嵌入可以在不需要任何代理的集群的其他代理的原有知识或协作的情况下终止一个代理。如果代理终止不是由于在集群中的自身或另一代理程序性的行动所实现而是通过外部集群的力量实现的，那么嵌入必须选择两种策略之一：要么终止集群中的所有代理，那么提供可靠的 API（允许集群中的代理相互协调，以便于至少存在一个集群的剩余成员能够检测这个终止，用包含足够信息的终止数据来确定被终止的代理）。

Note 5

这种终止类型的例子是：操作系统或用户终止代理在单独的进程中运行；当每个代理资源会计都表明该代理失控时，嵌入本身会终止一个正在与其他代理一起运行的代理。

在集群中的任何代理的任何 ES 代码的任何评价之前，对于在这个集群中的所有代理，代理记录的 [[CandidateExecution]] 字段会被设置为初始候选执行。初始候选执行是一个空候选执行，它的 [[EventLists]] 字段是一个列表，包含每个代理和一个代理事件记录（它的 [[AgentSignifier]] 字段是那个代理的 signifier 和它的 [[EventList]] 字段是一个空列表）。

Note 6

在代理集群中的所有代理在它的代理记录的 [[CandidateExecution] 字段中共享相同的候选执行。候选执行是内存模型使用的一种规范机制。

Note 7

代理集群是一个规范机制，不需要对应于一个 ES 实现的任何特定的人工制品。

8.9Forward Progress

对于一个代理而言，根据本规范 to make forward progress是为它执行一个评价步骤。

当它的运行时执行上下文同步地、无限期地等待一个外部事件时，代理就会被阻塞。只有代理记录的 [[CanBlock]] 属性是 true 时的代理，才可以在这个场景下被锁。一个没有锁的代理是不会被锁的。

实现必须确保：

every unblocked agent with a dedicated executing thread eventually makes forward progress
in a set of 代理 that share an executing thread, one agent eventually makes forward progress
an agent does not cause another agent to become blocked except via explicit APIs that provide blocking.

Note

This, along with the liveness guarantee in the 内存模型, ensures that all "SeqCst" writes eventually become observable to all 代理.

9普通对象和外来对象的行为

9.1普通对象的内部方法和内部属性

所有普通对象都有一个叫做 [[Prototype]] 的内部属性。这个内部属性的值是 null 或一个对象，用于实现继承。当为了获得访问，[[Prototype]] 对象的数据属性是可以被继承（且以作为子对象属性实现可见）的，但不能用于设置访问。访问器属性对于访问的设置和获取都是可以被继承的。

每个普通对象都有一个是布尔值的 [[Extensible]] 内部属性，它用来控制是否可以将属性添加到对象中。如果 [[Extensible]] 内部属性的值为 false，则不能向该对象添加其他的属性。此外，如果 [[Extensible]] 是 false，对象的 [[Prototype]] 内部属性的值可能不会被修改。当一个对象的 [[Extensible]] 内部属性的值被设置为 false 后，它可能不会被更改为 true。

在下面的算法描述，假设 O 是一个普通的对象，P 是一个属性的键值，V 是任一 ES 语言值， Desc 是一个属性描述符记录。

每个普通对象的内部方法都委托给一个类似命名的抽象操作。如果这样的抽象操作依赖于另一个内部方法，那么在 O 上调用该内部方法，而不是直接调用类似命名的抽象操作。这些语义确保外来对象在使用普通对象的内部方法时，其重写的内部方法将会被调用。

9.1.1[[GetPrototypeOf]] ( )

When the [[GetPrototypeOf]] 内部方法 of O is called, 执行如下:

Return ! OrdinaryGetPrototypeOf(O).

9.1.1.1OrdinaryGetPrototypeOf ( `O` )

When the 抽象操作 OrdinaryGetPrototypeOf is called with Object O, 执行如下:

Return O.[[Prototype]].

9.1.2[[SetPrototypeOf]] ( `V` )

When the [[SetPrototypeOf]] 内部方法 of O is called with argument V, 执行如下:

Return ! OrdinarySetPrototypeOf(O, V).

9.1.2.1OrdinarySetPrototypeOf ( `O`, `V` )

When the 抽象操作 OrdinarySetPrototypeOf is called with Object O and value V, 执行如下:

Assert: Either Type(V) is Object or Type(V) is Null.
Let extensible be O.[[Extensible]].
Let current be O.[[Prototype]].
If SameValue(V, current) is true, return true.
If extensible is false, return false.
Let p be V.
Let done be false.
Repeat, while done is false,
1. If p is null, set done to true.
2. Else if SameValue(p, O) is true, return false.
3. Else,
  1. If p.[[GetPrototypeOf]] is not the 普通对象内部方法 defined in 9.1.1, set done to true.
  2. Else, set p to p.[[Prototype]].
Set O.[[Prototype]] to V.
Return true.

Note

The loop in step 8 guarantees that there will be no circularities in any prototype chain that only includes objects that use the 普通对象 definitions for [[GetPrototypeOf]] and [[SetPrototypeOf]].

9.1.3[[IsExtensible]] ( )

When the [[IsExtensible]] 内部方法 of O is called, 执行如下:

Return ! OrdinaryIsExtensible(O).

9.1.3.1OrdinaryIsExtensible ( `O` )

When the 抽象操作 OrdinaryIsExtensible is called with Object O, 执行如下:

Return O.[[Extensible]].

9.1.4[[PreventExtensions]] ( )

When the [[PreventExtensions]] 内部方法 of O is called, 执行如下:

Return ! OrdinaryPreventExtensions(O).

9.1.4.1OrdinaryPreventExtensions ( `O` )

When the 抽象操作 OrdinaryPreventExtensions is called with Object O, 执行如下:

Set O.[[Extensible]] to false.
Return true.

9.1.5[[GetOwnProperty]] ( `P` )

When the [[GetOwnProperty]] 内部方法 of O is called with property key P, 执行如下:

Return ! OrdinaryGetOwnProperty(O, P).

9.1.5.1OrdinaryGetOwnProperty ( `O`, `P` )

When the 抽象操作 OrdinaryGetOwnProperty is called with Object O and with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
If O does not have an 自身属性 with key P, return undefined.
Let D be a newly created 属性描述符 with no fields.
Let X be O's 自身属性 whose key is P.
If X is a 数据属性, then
1. Set D.[[Value]] to the value of X's [[Value]] 特性.
2. Set D.[[Writable]] to the value of X's [[Writable]] 特性.
Else X is an 访问器属性,
1. Set D.[[Get]] to the value of X's [[Get]] 特性.
2. Set D.[[Set]] to the value of X's [[Set]] 特性.
Set D.[[Enumerable]] to the value of X's [[Enumerable]] 特性.
Set D.[[Configurable]] to the value of X's [[Configurable]] 特性.
Return D.

9.1.6[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of O is called with property key P and 属性描述符 Desc, 执行如下:

Return ? OrdinaryDefineOwnProperty(O, P, Desc).

9.1.6.1OrdinaryDefineOwnProperty ( `O`, `P`, `Desc` )

When the 抽象操作 OrdinaryDefineOwnProperty is called with Object O, property key P, and 属性描述符 Desc, 执行如下:

Let current be ? O.[[GetOwnProperty]](P).
Let extensible be O.[[Extensible]].
Return ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current).

9.1.6.2IsCompatiblePropertyDescriptor ( `Extensible`, `Desc`, `Current` )

When the 抽象操作 IsCompatiblePropertyDescriptor is called with Boolean 值 Extensible, and Property Descriptors Desc, and Current, 执行如下:

Return ValidateAndApplyPropertyDescriptor(undefined, undefined, Extensible, Desc, Current).

9.1.6.3ValidateAndApplyPropertyDescriptor ( `O`, `P`, `extensible`, `Desc`, `current` )

When the 抽象操作 ValidateAndApplyPropertyDescriptor is called with Object O, property key P, Boolean 值 extensible, and Property Descriptors Desc, and current, 执行如下:

Note

If undefined is passed as O, only validation is performed and no object updates are performed.

Assert: If O is not undefined, then IsPropertyKey(P) is true.
If current is undefined, then
1. If extensible is false, return false.
2. Assert: extensible is true.
3. If IsGenericDescriptor(Desc) is true or IsDataDescriptor(Desc) is true, then
  1. If O is not undefined, create an own 数据属性 named P of object O whose [[Value]], [[Writable]], [[Enumerable]] and [[Configurable]] 特性 values are described by Desc. If the value of an 特性 field of Desc is absent, the 特性 of the newly created property is set to its 默认值.
4. Else Desc must be an accessor 属性描述符,
  1. If O is not undefined, create an own 访问器属性 named P of object O whose [[Get]], [[Set]], [[Enumerable]] and [[Configurable]] 特性 values are described by Desc. If the value of an 特性 field of Desc is absent, the 特性 of the newly created property is set to its 默认值.
5. Return true.
If every field in Desc is absent, return true.
If current.[[Configurable]] is false, then
1. If Desc.[[Configurable]] is present and its value is true, return false.
2. If Desc.[[Enumerable]] is present and the [[Enumerable]] fields of current and Desc are the Boolean negation of each other, return false.
If IsGenericDescriptor(Desc) is true, no further validation is required.
Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) have different results, then
1. If current.[[Configurable]] is false, return false.
2. If IsDataDescriptor(current) is true, then
  1. If O is not undefined, convert the property named P of object O from a 数据属性 to an 访问器属性. Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] 特性 and set the rest of the property's 特性 to their default values.
3. Else,
  1. If O is not undefined, convert the property named P of object O from an 访问器属性 to a 数据属性. Preserve the existing values of the converted property's [[Configurable]] and [[Enumerable]] 特性 and set the rest of the property's 特性 to their default values.
Else if IsDataDescriptor(current) and IsDataDescriptor(Desc) are both true, then
1. If current.[[Configurable]] is false and current.[[Writable]] is false, then
  1. If Desc.[[Writable]] is present and Desc.[[Writable]] is true, return false.
  2. If Desc.[[Value]] is present and SameValue(Desc.[[Value]], current.[[Value]]) is false, return false.
  3. Return true.
Else IsAccessorDescriptor(current) and IsAccessorDescriptor(Desc) are both true,
1. If current.[[Configurable]] is false, then
  1. If Desc.[[Set]] is present and SameValue(Desc.[[Set]], current.[[Set]]) is false, return false.
  2. If Desc.[[Get]] is present and SameValue(Desc.[[Get]], current.[[Get]]) is false, return false.
  3. Return true.
If O is not undefined, then
1. For each field of Desc that is present, set the corresponding 特性 of the property named P of object O to the value of the field.
Return true.

9.1.7[[HasProperty]]( `P` )

When the [[HasProperty]] 内部方法 of O is called with property key P, 执行如下:

Return ? OrdinaryHasProperty(O, P).

9.1.7.1OrdinaryHasProperty ( `O`, `P` )

When the 抽象操作 OrdinaryHasProperty is called with Object O and with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let hasOwn be ? O.[[GetOwnProperty]](P).
If hasOwn is not undefined, return true.
Let parent be ? O.[[GetPrototypeOf]]().
If parent is not null, then
1. Return ? parent.[[HasProperty]](P).
Return false.

9.1.8[[Get]] ( `P`, `Receiver` )

When the [[Get]] 内部方法 of O is called with property key P and ES 语言值 Receiver, 执行如下:

Return ? OrdinaryGet(O, P, Receiver).

9.1.8.1OrdinaryGet ( `O`, `P`, `Receiver` )

When the 抽象操作 OrdinaryGet is called with Object O, property key P, and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
Let desc be ? O.[[GetOwnProperty]](P).
If desc is undefined, then
1. Let parent be ? O.[[GetPrototypeOf]]().
2. If parent is null, return undefined.
3. Return ? parent.[[Get]](P, Receiver).
If IsDataDescriptor(desc) is true, return desc.[[Value]].
Assert: IsAccessorDescriptor(desc) is true.
Let getter be desc.[[Get]].
If getter is undefined, return undefined.
Return ? Call(getter, Receiver).

9.1.9[[Set]] ( `P`, `V`, `Receiver` )

When the [[Set]] 内部方法 of O is called with property key P, value V, and ES 语言值 Receiver, 执行如下:

Return ? OrdinarySet(O, P, V, Receiver).

9.1.9.1OrdinarySet ( `O`, `P`, `V`, `Receiver` )

When the 抽象操作 OrdinarySet is called with Object O, property key P, value V, and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
Let ownDesc be ? O.[[GetOwnProperty]](P).
Return OrdinarySetWithOwnDescriptor(O, P, V, Receiver, ownDesc).

9.1.9.2OrdinarySetWithOwnDescriptor ( `O`, `P`, `V`, `Receiver`, `ownDesc` )

When the 抽象操作 OrdinarySetWithOwnDescriptor is called with Object O, property key P, value V, ES 语言值 Receiver, and 属性描述符 (or undefined) ownDesc, 执行如下:

Assert: IsPropertyKey(P) is true.
If ownDesc is undefined, then
1. Let parent be ? O.[[GetPrototypeOf]]().
2. If parent is not null, then
  1. Return ? parent.[[Set]](P, V, Receiver).
3. Else,
  1. Set ownDesc to the PropertyDescriptor{[[Value]]: undefined, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}.
If IsDataDescriptor(ownDesc) is true, then
1. If ownDesc.[[Writable]] is false, return false.
2. If Type(Receiver) is not Object, return false.
3. Let existingDescriptor be ? Receiver.[[GetOwnProperty]](P).
4. If existingDescriptor is not undefined, then
  1. If IsAccessorDescriptor(existingDescriptor) is true, return false.
  2. If existingDescriptor.[[Writable]] is false, return false.
  3. Let valueDesc be the PropertyDescriptor{[[Value]]: V}.
  4. Return ? Receiver.[[DefineOwnProperty]](P, valueDesc).
5. Else Receiver does not currently have a property P,
  1. Return ? CreateDataProperty(Receiver, P, V).
Assert: IsAccessorDescriptor(ownDesc) is true.
Let setter be ownDesc.[[Set]].
If setter is undefined, return false.
Perform ? Call(setter, Receiver, « V »).
Return true.

9.1.10[[Delete]] ( `P` )

When the [[Delete]] 内部方法 of O is called with property key P, 执行如下:

Return ? OrdinaryDelete(O, P).

9.1.10.1OrdinaryDelete ( `O`, `P` )

When the 抽象操作 OrdinaryDelete is called with Object O and property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let desc be ? O.[[GetOwnProperty]](P).
If desc is undefined, return true.
If desc.[[Configurable]] is true, then
1. Remove the 自身属性 with name P from O.
2. Return true.
Return false.

9.1.11[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] 内部方法 of O is called, 执行如下:

Return ! OrdinaryOwnPropertyKeys(O).

9.1.11.1OrdinaryOwnPropertyKeys ( `O` )

When the 抽象操作 OrdinaryOwnPropertyKeys is called with Object O, 执行如下:

Let keys be a new empty List.
For each 自身属性 key P of O that is an 整数索引, in ascending numeric index order, do
1. Add P as the last element of keys.
For each 自身属性 key P of O that is a String but is not an 整数索引, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
For each 自身属性 key P of O that is a Symbol, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
Return keys.

9.1.12ObjectCreate ( `proto` [ , `internalSlotsList` ] )

The 抽象操作 ObjectCreate with argument proto (an object or null) is used to specify the runtime creation of new 普通对象. The 可选参数 internalSlotsList is a List of the names of additional 内部属性 that must be defined as part of the object. If the list is not provided, a new empty List is used. This 抽象操作执行如下:

If internalSlotsList is not present, set internalSlotsList to a new empty List.
Let obj be a newly created object with an 内部属性 for each name in internalSlotsList.
Set obj's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set obj.[[Prototype]] to proto.
Set obj.[[Extensible]] to true.
Return obj.

9.1.13OrdinaryCreateFromConstructor ( `构造器`, `intrinsicDefaultProto` [ , `internalSlotsList` ] )

The 抽象操作 OrdinaryCreateFromConstructor creates an 普通对象 whose [[Prototype]] value is retrieved from a 构造器's prototype property, if it exists. Otherwise the intrinsic named by intrinsicDefaultProto is used for [[Prototype]]. The optional internalSlotsList is a List of the names of additional 内部属性 that must be defined as part of the object. If the list is not provided, a new empty List is used. This 抽象操作执行如下:

Assert: intrinsicDefaultProto is a String 值 that is this specification's name of an 内部对象. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
Let proto be ? GetPrototypeFromConstructor(构造器, intrinsicDefaultProto).
Return ObjectCreate(proto, internalSlotsList).

9.1.14GetPrototypeFromConstructor ( `构造器`, `intrinsicDefaultProto` )

The 抽象操作 GetPrototypeFromConstructor determines the [[Prototype]] value that should be used to create an object corresponding to a specific 构造器. The value is retrieved from the 构造器's prototype property, if it exists. Otherwise the intrinsic named by intrinsicDefaultProto is used for [[Prototype]]. This 抽象操作执行如下:

Assert: intrinsicDefaultProto is a String 值 that is this specification's name of an 内部对象. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
Assert: IsCallable(构造器) is true.
Let proto be ? Get(构造器, "prototype").
If Type(proto) is not Object, then
1. Let realm be ? GetFunctionRealm(构造器).
2. Set proto to realm's 内部对象 named intrinsicDefaultProto.
Return proto.

Note

If 构造器 does not supply a [[Prototype]] value, the 默认值 that is used is obtained from the realm of the 构造器 function rather than from the 运行时执行上下文.

9.2ES 函数对象

ES 函数对象 encapsulate parameterized ES 代码 closed over a 词法环境 and support the dynamic 估值 of that code. An ES 函数对象 is an 普通对象 and has the same 内部属性 and the same 内部方法 as other 普通对象. The code of an ES 函数对象 may be either 严格模式代码 (10.2.1) or non-strict code. An ES 函数对象 whose code is 严格模式代码 is called a strict function. One whose code is not 严格模式代码 is called a non-strict function.

ES 函数对象 have the additional 内部属性 listed in Table 27.

Table 27: 内部属性 of ES 函数对象

内部属性	Type	Description
[[Environment]]	词法环境	The 词法环境 that the function was closed over. Used as the outer environment when evaluating the code of the function.
[[FormalParameters]]	解析节点	The root 解析节点 of the 源文本 that defines the function's formal parameter list.
[[FunctionKind]]	String	Either `"normal"`, `"classConstructor"`, `"generator"`, or `"async"`.
[[ECMAScriptCode]]	解析节点	The root 解析节点 of the 源文本 that defines the function's body.
[[ConstructorKind]]	String	Either `"base"` or `"derived"`.
[[Realm]]	Realm Record	The realm in which the function was created and which provides any intrinsic objects that are accessed when evaluating the function.
[[ScriptOrModule]]	脚本记录 or Module Record	The script or module in which the function was created.
[[ThisMode]]	(lexical, strict, global)	Defines how `this` references are interpreted within the formal parameters and code body of the function. lexical means that `this` refers to the this value of a lexically enclosing function. strict means that the this value is used exactly as provided by an invocation of the function. global means that a this value of undefined is interpreted as a reference to the 全局对象.
[[Strict]]	Boolean	true if this is a strict function, false if this is a non-strict function.
[[HomeObject]]	Object	If the function uses `super`, this is the object whose [[GetPrototypeOf]] provides the object where `super` property lookups begin.

All ES 函数对象 have the [[Call]] 内部方法 defined here. ES functions that are also constructors in addition have the [[Construct]] 内部方法.

9.2.1[[Call]] ( `thisArgument`, `argumentsList` )

The [[Call]] 内部方法 for an ES 函数对象 F is called with parameters thisArgument and argumentsList, a List of ES 语言值. 执行如下:

Assert: F is an ES 函数对象.
If F.[[FunctionKind]] is "classConstructor", 抛出一个 TypeError 异常.
Let callerContext be the 运行时执行上下文.
Let calleeContext be PrepareForOrdinaryCall(F, undefined).
Assert: calleeContext is now the 运行时执行上下文.
Perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
Let result be OrdinaryCallEvaluateBody(F, argumentsList).
Remove calleeContext from the 执行上下文堆栈 and restore callerContext as the 运行时执行上下文.
If result.[[Type]] is return, return NormalCompletion(result.[[Value]]).
ReturnIfAbrupt(result).
Return NormalCompletion(undefined).

Note

When calleeContext is removed from the 执行上下文堆栈 in step 8 it must not be destroyed if it is suspended and retained for later resumption by an accessible 生成器对象.

9.2.1.1PrepareForOrdinaryCall ( `F`, `newTarget` )

When the 抽象操作 PrepareForOrdinaryCall is called with 函数对象 F and ES 语言值 newTarget, 执行如下:

Assert: Type(newTarget) is Undefined or Object.
Let callerContext be the 运行时执行上下文.
Let calleeContext be a new ES 代码执行上下文.
Set the Function of calleeContext to F.
Let calleeRealm be F.[[Realm]].
Set the Realm of calleeContext to calleeRealm.
Set the ScriptOrModule of calleeContext to F.[[ScriptOrModule]].
Let localEnv be NewFunctionEnvironment(F, newTarget).
Set the LexicalEnvironment of calleeContext to localEnv.
Set the VariableEnvironment of calleeContext to localEnv.
If callerContext is not already suspended, suspend callerContext.
Push calleeContext onto the 执行上下文堆栈; calleeContext is now the 运行时执行上下文.
NOTE: Any 异常 objects produced after this point are associated with calleeRealm.
Return calleeContext.

9.2.1.2OrdinaryCallBindThis ( `F`, `calleeContext`, `thisArgument` )

When the 抽象操作 OrdinaryCallBindThis is called with 函数对象 F, 执行上下文 calleeContext, and ES 值 thisArgument, 执行如下:

Let thisMode be F.[[ThisMode]].
If thisMode is lexical, return NormalCompletion(undefined).
Let calleeRealm be F.[[Realm]].
Let localEnv be the LexicalEnvironment of calleeContext.
If thisMode is strict, let thisValue be thisArgument.
Else,
1. If thisArgument is undefined or null, then
  1. Let globalEnv be calleeRealm.[[GlobalEnv]].
  2. Let globalEnvRec be globalEnv's EnvironmentRecord.
  3. Assert: globalEnvRec is a global 环境记录.
  4. Let thisValue be globalEnvRec.[[GlobalThisValue]].
2. Else,
  1. Let thisValue be ! ToObject(thisArgument).
  2. NOTE: ToObject produces wrapper objects using calleeRealm.
Let envRec be localEnv's EnvironmentRecord.
Assert: envRec is a 函数环境记录.
Assert: The next step never returns an abrupt completion because envRec.[[ThisBindingStatus]] is not "initialized".
Return envRec.BindThisValue(thisValue).

9.2.1.3OrdinaryCallEvaluateBody ( `F`, `argumentsList` )

When the 抽象操作 OrdinaryCallEvaluateBody is called with 函数对象 F and List argumentsList, 执行如下:

Return the result of EvaluateBody of the parsed code that is F.[[ECMAScriptCode]] passing F and argumentsList as the arguments.

9.2.2[[Construct]] ( `argumentsList`, `newTarget` )

The [[Construct]] 内部方法 for an ES 函数对象 F is called with parameters argumentsList and newTarget. argumentsList is a possibly empty List of ES 语言值. 执行如下:

Assert: F is an ES 函数对象.
Assert: Type(newTarget) is Object.
Let callerContext be the 运行时执行上下文.
Let kind be F.[[ConstructorKind]].
If kind is "base", then
1. Let thisArgument be ? OrdinaryCreateFromConstructor(newTarget, "%ObjectPrototype%").
Let calleeContext be PrepareForOrdinaryCall(F, newTarget).
Assert: calleeContext is now the 运行时执行上下文.
If kind is "base", perform OrdinaryCallBindThis(F, calleeContext, thisArgument).
Let constructorEnv be the LexicalEnvironment of calleeContext.
Let envRec be constructorEnv's EnvironmentRecord.
Let result be OrdinaryCallEvaluateBody(F, argumentsList).
Remove calleeContext from the 执行上下文堆栈 and restore callerContext as the 运行时执行上下文.
If result.[[Type]] is return, then
1. If Type(result.[[Value]]) is Object, return NormalCompletion(result.[[Value]]).
2. If kind is "base", return NormalCompletion(thisArgument).
3. If result.[[Value]] is not undefined, 抛出一个 TypeError 异常.
Else, ReturnIfAbrupt(result).
Return ? envRec.GetThisBinding().

9.2.3FunctionAllocate ( `functionPrototype`, `strict`, `functionKind` )

The 抽象操作 FunctionAllocate requires the three arguments functionPrototype, strict and functionKind. FunctionAllocate 执行如下:

Assert: Type(functionPrototype) is Object.
Assert: functionKind is either "normal", "non-构造器", "generator", "async", or "async generator".
If functionKind is "normal", let needsConstruct be true.
Else, let needsConstruct be false.
If functionKind is "non-构造器", set functionKind to "normal".
Let F be a newly created ES 函数对象 with the 内部属性 listed in Table 27. All of those 内部属性 are initialized to undefined.
Set F's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set F.[[Call]] to the definition specified in 9.2.1.
If needsConstruct is true, then
1. Set F.[[Construct]] to the definition specified in 9.2.2.
2. Set F.[[ConstructorKind]] to "base".
Set F.[[Strict]] to strict.
Set F.[[FunctionKind]] to functionKind.
Set F.[[Prototype]] to functionPrototype.
Set F.[[Extensible]] to true.
Set F.[[Realm]] to the current Realm Record.
Return F.

9.2.4FunctionInitialize ( `F`, `kind`, `ParameterList`, `Body`, `Scope` )

The 抽象操作 FunctionInitialize requires the arguments: a 函数对象 F, kind which is one of (Normal, Method, Arrow), a parameter list 解析节点 specified by ParameterList, a body 解析节点 specified by Body, a 词法环境 specified by Scope. FunctionInitialize 执行如下:

Assert: F is an extensible object that does not have a length 自身属性.
Let len be the ExpectedArgumentCount of ParameterList.
Perform ! DefinePropertyOrThrow(F, "length", PropertyDescriptor{[[Value]]: len, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true}).
Let Strict be F.[[Strict]].
Set F.[[Environment]] to Scope.
Set F.[[FormalParameters]] to ParameterList.
Set F.[[ECMAScriptCode]] to Body.
Set F.[[ScriptOrModule]] to GetActiveScriptOrModule().
If kind is Arrow, set F.[[ThisMode]] to lexical.
Else if Strict is true, set F.[[ThisMode]] to strict.
Else, set F.[[ThisMode]] to global.
Return F.

9.2.5FunctionCreate ( `kind`, `ParameterList`, `Body`, `Scope`, `Strict` [ , `prototype` ] )

The 抽象操作 FunctionCreate requires the arguments: kind which is one of (Normal, Method, Arrow), a parameter list 解析节点 specified by ParameterList, a body 解析节点 specified by Body, a 词法环境 specified by Scope, a Boolean flag Strict, and optionally, an object prototype. FunctionCreate 执行如下:

If prototype is not present, then
1. Set prototype to the 内部对象 %FunctionPrototype%.
If kind is not Normal, let allocKind be "non-构造器".
Else, let allocKind be "normal".
Let F be FunctionAllocate(prototype, Strict, allocKind).
Return FunctionInitialize(F, kind, ParameterList, Body, Scope).

9.2.6GeneratorFunctionCreate ( `kind`, `ParameterList`, `Body`, `Scope`, `Strict` )

The 抽象操作 GeneratorFunctionCreate requires the arguments: kind which is one of (Normal, Method), a parameter list 解析节点 specified by ParameterList, a body 解析节点 specified by Body, a 词法环境 specified by Scope, and a Boolean flag Strict. GeneratorFunctionCreate 执行如下:

Let functionPrototype be the 内部对象 %Generator%.
Let F be FunctionAllocate(functionPrototype, Strict, "generator").
Return FunctionInitialize(F, kind, ParameterList, Body, Scope).

9.2.7AsyncGeneratorFunctionCreate (`kind`, `ParameterList`, `Body`, `Scope`, `Strict`)

The 抽象操作 AsyncGeneratorFunctionCreate requires the arguments: kind which is one of (Normal, Method), a parameter list 解析节点 specified by ParameterList, a body 解析节点 specified by Body, a 词法环境 specified by Scope, and a Boolean flag Strict. AsyncGeneratorFunctionCreate 执行如下:

Let functionPrototype be the 内部对象 %AsyncGenerator%.
Let F be ! FunctionAllocate(functionPrototype, Strict, "generator").
Return ! FunctionInitialize(F, kind, ParameterList, Body, Scope).

9.2.8AddRestrictedFunctionProperties ( `F`, `realm` )

The 抽象操作 AddRestrictedFunctionProperties is called with a 函数对象 F and Realm Record realm as its argument. It 执行如下:

Assert: realm.[[Intrinsics]].[[%ThrowTypeError%]] exists and has been initialized.
Let thrower be realm.[[Intrinsics]].[[%ThrowTypeError%]].
Perform ! DefinePropertyOrThrow(F, "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: true}).
Return ! DefinePropertyOrThrow(F, "arguments", PropertyDescriptor {[[Get]]: thrower, [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: true}).

9.2.8.1%ThrowTypeError% ( )

The %ThrowTypeError% intrinsic is an anonymous 内置函数对象 that is defined once for each realm. When %ThrowTypeError% is called it 执行如下:

抛出一个 TypeError 异常.

The value of the [[Extensible]] 内部属性 of a %ThrowTypeError% function is false.

The length property of a %ThrowTypeError% function has the 特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

9.2.9MakeConstructor ( `F` [ , `writablePrototype` [ , `prototype` ] ] )

The 抽象操作 MakeConstructor requires a Function argument F and optionally, a Boolean writablePrototype and an object prototype. If prototype is provided it is assumed to already contain, if needed, a "构造器" property whose value is F. This operation converts F into a 构造器 by performing the following steps:

Assert: F is an ES 函数对象.
Assert: IsConstructor(F) is true.
Assert: F is an extensible object that does not have a prototype 自身属性.
If writablePrototype is not present, set writablePrototype to true.
If prototype is not present, then
1. Set prototype to ObjectCreate(%ObjectPrototype%).
2. Perform ! DefinePropertyOrThrow(prototype, "构造器", PropertyDescriptor{[[Value]]: F, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: true }).
Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: writablePrototype, [[Enumerable]]: false, [[Configurable]]: false}).
Return NormalCompletion(undefined).

9.2.10MakeClassConstructor ( `F` )

The 抽象操作 MakeClassConstructor with argument F 执行如下:

Assert: F is an ES 函数对象.
Assert: F.[[FunctionKind]] is "normal".
Set F.[[FunctionKind]] to "classConstructor".
Return NormalCompletion(undefined).

9.2.11MakeMethod ( `F`, `homeObject` )

The 抽象操作 MakeMethod with arguments F and homeObject configures F as a method by performing the following steps:

Assert: F is an ES 函数对象.
Assert: Type(homeObject) is Object.
Set F.[[HomeObject]] to homeObject.
Return NormalCompletion(undefined).

9.2.12SetFunctionName ( `F`, `name` [ , `prefix` ] )

The 抽象操作 SetFunctionName requires a Function argument F, a String or Symbol argument name and optionally a String argument prefix. This operation adds a name property to F by performing the following steps:

Assert: F is an extensible object that does not have a name 自身属性.
Assert: Type(name) is either Symbol or String.
Assert: If prefix is present, then Type(prefix) is String.
If Type(name) is Symbol, then
1. Let description be name's [[Description]] value.
2. If description is undefined, set name to the empty String.
3. Else, set name to the string-concatenation of "[", description, and "]".
If prefix is present, then
1. Set name to the string-concatenation of prefix, the 代码单元 0x0020 (SPACE), and name.
Return ! DefinePropertyOrThrow(F, "name", PropertyDescriptor{[[Value]]: name, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true}).

9.2.13FunctionDeclarationInstantiation ( `func`, `argumentsList` )

Note 1

When an 执行上下文 is established for evaluating an ES function a new 函数环境记录 is created and bindings for each formal parameter are instantiated in that 环境记录. Each declaration in the function body is also instantiated. If the function's formal parameters do not include any 默认值初始化器 then the body declarations are instantiated in the same 环境记录 as the parameters. If 默认值 parameter 初始化器 exist, a second 环境记录 is created for the body declarations. Formal parameters and functions are initialized as part of FunctionDeclarationInstantiation. All other bindings are initialized during 估值 of the function body.

FunctionDeclarationInstantiation is performed as follows using arguments func and argumentsList. func is the 函数对象 for which the 执行上下文 is being established.

Let calleeContext be the 运行时执行上下文.
Let env be the LexicalEnvironment of calleeContext.
Let envRec be env's EnvironmentRecord.
Let code be func.[[ECMAScriptCode]].
Let strict be func.[[Strict]].
Let formals be func.[[FormalParameters]].
Let parameterNames be the 绑定名 of formals.
If parameterNames has any duplicate entries, let hasDuplicates be true. Otherwise, let hasDuplicates be false.
Let simpleParameterList be IsSimpleParameterList of formals.
Let hasParameterExpressions be ContainsExpression of formals.
Let varNames be the VarDeclaredNames of code.
Let varDeclarations be the VarScopedDeclarations of code.
Let lexicalNames be the LexicallyDeclaredNames of code.
Let functionNames be a new empty List.
Let functionsToInitialize be a new empty List.
For each d in varDeclarations, in reverse list order, do
1. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
  1. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
  2. Let fn be the sole element of the 绑定名 of d.
  3. If fn is not an element of functionNames, then
    1. Insert fn as the first element of functionNames.
    2. NOTE: If there are multiple 函数声明 for the same name, the last declaration is used.
    3. Insert d as the first element of functionsToInitialize.
Let argumentsObjectNeeded be true.
If func.[[ThisMode]] is lexical, then
1. NOTE: Arrow functions never have an arguments objects.
2. Set argumentsObjectNeeded to false.
Else if "arguments" is an element of parameterNames, then
1. Set argumentsObjectNeeded to false.
Else if hasParameterExpressions is false, then
1. If "arguments" is an element of functionNames or if "arguments" is an element of lexicalNames, then
  1. Set argumentsObjectNeeded to false.
For each String paramName in parameterNames, do
1. Let alreadyDeclared be envRec.HasBinding(paramName).
2. NOTE: 早期错误 ensure that duplicate parameter names can only occur in non-strict functions that do not have parameter default values or rest parameters.
3. If alreadyDeclared is false, then
  1. Perform ! envRec.CreateMutableBinding(paramName, false).
  2. If hasDuplicates is true, then
    1. Perform ! envRec.InitializeBinding(paramName, undefined).
If argumentsObjectNeeded is true, then
1. If strict is true or if simpleParameterList is false, then
  1. Let ao be CreateUnmappedArgumentsObject(argumentsList).
2. Else,
  1. NOTE: mapped argument object is only provided for non-strict functions that don't have a rest parameter, any parameter 默认值初始化器, or any destructured parameters.
  2. Let ao be CreateMappedArgumentsObject(func, formals, argumentsList, envRec).
3. If strict is true, then
  1. Perform ! envRec.CreateImmutableBinding("arguments", false).
4. Else,
  1. Perform ! envRec.CreateMutableBinding("arguments", false).
5. Call envRec.InitializeBinding("arguments", ao).
6. Let parameterBindings be a new List of parameterNames with "arguments" appended.
Else,
1. Let parameterBindings be parameterNames.
Let iteratorRecord be CreateListIteratorRecord(argumentsList).
If hasDuplicates is true, then
1. Perform ? IteratorBindingInitialization for formals with iteratorRecord and undefined as arguments.
Else,
1. Perform ? IteratorBindingInitialization for formals with iteratorRecord and env as arguments.
If hasParameterExpressions is false, then
1. NOTE: Only a single 词法环境 is needed for the parameters and top-level vars.
2. Let instantiatedVarNames be a copy of the List parameterBindings.
3. For each n in varNames, do
  1. If n is not an element of instantiatedVarNames, then
    1. Append n to instantiatedVarNames.
    2. Perform ! envRec.CreateMutableBinding(n, false).
    3. Call envRec.InitializeBinding(n, undefined).
4. Let varEnv be env.
5. Let varEnvRec be envRec.
Else,
1. NOTE: A separate 环境记录 is needed to ensure that closures created by expressions in the formal parameter list do not have visibility of declarations in the function body.
2. Let varEnv be NewDeclarativeEnvironment(env).
3. Let varEnvRec be varEnv's EnvironmentRecord.
4. Set the VariableEnvironment of calleeContext to varEnv.
5. Let instantiatedVarNames be a new empty List.
6. For each n in varNames, do
  1. If n is not an element of instantiatedVarNames, then
    1. Append n to instantiatedVarNames.
    2. Perform ! varEnvRec.CreateMutableBinding(n, false).
    3. If n is not an element of parameterBindings or if n is an element of functionNames, let initialValue be undefined.
    4. Else,
      1. Let initialValue be ! envRec.GetBindingValue(n, false).
    5. Call varEnvRec.InitializeBinding(n, initialValue).
    6. NOTE: vars whose names are the same as a formal parameter, initially have the same value as the corresponding initialized parameter.
NOTE: Annex B.3.3.1 adds additional steps at this point.
If strict is false, then
1. Let lexEnv be NewDeclarativeEnvironment(varEnv).
2. NOTE: Non-strict functions use a separate lexical 环境记录 for top-level lexical declarations so that a direct eval can determine whether any var scoped declarations introduced by the eval code conflict with pre-existing top-level lexically scoped declarations. This is not needed for strict functions because a strict direct eval always places all declarations into a new 环境记录.
Else, let lexEnv be varEnv.
Let lexEnvRec be lexEnv's EnvironmentRecord.
Set the LexicalEnvironment of calleeContext to lexEnv.
Let lexDeclarations be the LexicallyScopedDeclarations of code.
For each element d in lexDeclarations, do
1. NOTE: A lexically declared name cannot be the same as a function/generator declaration, formal parameter, or a var name. Lexically declared names are only instantiated here but not initialized.
2. For each element dn of the 绑定名 of d, do
  1. If IsConstantDeclaration of d is true, then
    1. Perform ! lexEnvRec.CreateImmutableBinding(dn, true).
  2. Else,
    1. Perform ! lexEnvRec.CreateMutableBinding(dn, false).
For each 解析节点 f in functionsToInitialize, do
1. Let fn be the sole element of the 绑定名 of f.
2. Let fo be the result of performing InstantiateFunctionObject for f with argument lexEnv.
3. Perform ! varEnvRec.SetMutableBinding(fn, fo, false).
Return NormalCompletion(empty).

Note 2

B.3.3 provides an extension to the above 算法 that is necessary for backwards compatibility with web browser implementations of ES that predate ES 2015.

Note 3

Parameter 初始化器s may contain direct eval expressions. Any top level declarations of such evals are only visible to the eval code (10.2). The creation of the environment for such declarations is described in 14.1.19.

9.3内置函数对象

The 内置函数对象 defined 在本规范中 may be implemented as either ES 函数对象 (9.2) whose behaviour is provided using ES 代码 or as 实现 provided function 外来对象 whose behaviour is provided in some other manner. In either case, the effect of calling such functions must conform to their specifications. An 实现 may also provide additional 内置函数对象 that are not defined 在本规范中.

If a 内置函数对象 is implemented as an 外来对象 it must have the 普通对象 behaviour specified in 9.1. All such function 外来对象 also have [[Prototype]], [[Extensible]], [[Realm]], and [[ScriptOrModule]] 内部属性.

Unless otherwise specified every 内置函数对象 has the %FunctionPrototype% object as the 初始值 of its [[Prototype]] 内部属性.

The behaviour specified for each 内置函数 via 算法步骤 or other means is the specification of the function body behaviour for both [[Call]] and [[Construct]] invocations of the function. However, [[Construct]] invocation is not supported by all 内置 functions. For each 内置函数, when invoked with [[Call]], the [[Call]] thisArgument provides the this value, the [[Call]] argumentsList provides the named parameters, and the NewTarget value is undefined. When invoked with [[Construct]], the this value is uninitialized, the [[Construct]] argumentsList provides the named parameters, and the [[Construct]] newTarget parameter provides the NewTarget value. If the 内置函数 is implemented as an ES 函数对象 then this specified behaviour must be implemented by the ES 代码 that is the body of the function. 内置 functions that are ES 函数对象 must be strict functions. If a 内置构造器 has any [[Call]] behaviour other than throwing a TypeError 异常, an ES 实现 of the function must be done in a manner that does not cause the function's [[FunctionKind]] 内部属性 to have the value "classConstructor".

内置函数对象 that are not identified as constructors do not implement the [[Construct]] 内部方法 unless otherwise specified in the description of a particular function. When a 内置构造器 is called as part of a new expression the argumentsList parameter of the invoked [[Construct]] 内部方法 provides the values for the 内置构造器's named parameters.

内置 functions that are not constructors do not have a prototype property unless otherwise specified in the description of a particular function.

If a 内置函数对象 is not implemented as an ES function it must provide [[Call]] and [[Construct]] 内部方法 that conform to the following definitions:

9.3.1[[Call]] ( `thisArgument`, `argumentsList` )

The [[Call]] 内部方法 for a 内置函数对象 F is called with parameters thisArgument and argumentsList, a List of ES 语言值. 执行如下:

Let callerContext be the 运行时执行上下文.
If callerContext is not already suspended, suspend callerContext.
Let calleeContext be a new ES 代码执行上下文.
Set the Function of calleeContext to F.
Let calleeRealm be F.[[Realm]].
Set the Realm of calleeContext to calleeRealm.
Set the ScriptOrModule of calleeContext to F.[[ScriptOrModule]].
Perform any necessary 实现-defined initialization of calleeContext.
Push calleeContext onto the 执行上下文堆栈; calleeContext is now the 运行时执行上下文.
Let result be the 完成记录 that is the result of evaluating F in an 实现-defined manner that conforms to the specification of F. thisArgument is the this value, argumentsList provides the named parameters, and the NewTarget value is undefined.
Remove calleeContext from the 执行上下文堆栈 and restore callerContext as the 运行时执行上下文.
Return result.

Note

When calleeContext is removed from the 执行上下文堆栈 it must not be destroyed if it has been suspended and retained by an accessible 生成器对象 for later resumption.

9.3.2[[Construct]] ( `argumentsList`, `newTarget` )

The [[Construct]] 内部方法 for 内置函数对象 F is called with parameters argumentsList and newTarget. The steps performed are the same as [[Call]] (see 9.3.1) except that step 10 is replaced by:

Let result be the 完成记录 that is the result of evaluating F in an 实现-defined manner that conforms to the specification of F. The this value is uninitialized, argumentsList provides the named parameters, and newTarget provides the NewTarget value.

9.3.3CreateBuiltinFunction ( `steps`, `internalSlotsList` [ , `realm` [ , `prototype` ] ] )

The 抽象操作 CreateBuiltinFunction takes arguments steps, internalSlotsList, realm, and prototype. The argument internalSlotsList is a List of the names of additional 内部属性 that must be defined as part of the object. CreateBuiltinFunction returns a 内置函数对象 created by the following steps:

Assert: steps is either a set of 算法步骤 or other definition of a function's behaviour provided 在本规范中.
If realm is not present, set realm to the current Realm Record.
Assert: realm is a Realm Record.
If prototype is not present, set prototype to realm.[[Intrinsics]].[[%FunctionPrototype%]].
Let func be a new 内置函数对象 that when called performs the action described by steps. The new 函数对象 has 内部属性 whose names are the elements of internalSlotsList. The 初始值 of each of those 内部属性 is undefined.
Set func.[[Realm]] to realm.
Set func.[[Prototype]] to prototype.
Set func.[[Extensible]] to true.
Set func.[[ScriptOrModule]] to null.
Return func.

Each 内置函数 defined 在本规范中 is created by calling the CreateBuiltinFunction 抽象操作.

9.4内置外来对象的内部方法和内部属性

This specification defines several kinds of 内置外来对象. These objects generally behave similar to 普通对象 except for a few specific situations. The following 外来对象 use the 普通对象内部方法 except where it is explicitly specified otherwise below:

9.4.1绑定函数外来对象

A bound function is an 外来对象 that wraps another 函数对象. A bound function is callable (it has a [[Call]] 内部方法 and may have a [[Construct]] 内部方法). Calling a bound function generally results in a call of its wrapped function.

Bound 函数对象 do not have the 内部属性 of ES 函数对象 defined in Table 27. Instead they have the 内部属性 defined in Table 28.

Table 28: 内部属性 of 绑定函数外来对象

内部属性	Type	Description
[[BoundTargetFunction]]	Callable Object	The wrapped 函数对象.
[[BoundThis]]	Any	The value that is always passed as the this value when calling the wrapped function.
[[BoundArguments]]	List of Any	A list of values whose elements are used as the first arguments to any call to the wrapped function.

Bound 函数对象 provide all of the essential 内部方法 as specified in 9.1. However, they use the following definitions for the essential 内部方法 of 函数对象.

9.4.1.1[[Call]] ( `thisArgument`, `argumentsList` )

When the [[Call]] 内部方法 of a bound function 外来对象, F, which was created using the bind function is called with parameters thisArgument and argumentsList, a List of ES 语言值, 执行如下:

Let target be F.[[BoundTargetFunction]].
Let boundThis be F.[[BoundThis]].
Let boundArgs be F.[[BoundArguments]].
Let args be a new list containing the same values as the list boundArgs in the same order followed by the same values as the list argumentsList in the same order.
Return ? Call(target, boundThis, args).

9.4.1.2[[Construct]] ( `argumentsList`, `newTarget` )

When the [[Construct]] 内部方法 of a bound function 外来对象, F that was created using the bind function is called with a list of arguments argumentsList and newTarget, 执行如下:

Let target be F.[[BoundTargetFunction]].
Assert: IsConstructor(target) is true.
Let boundArgs be F.[[BoundArguments]].
Let args be a new list containing the same values as the list boundArgs in the same order followed by the same values as the list argumentsList in the same order.
If SameValue(F, newTarget) is true, set newTarget to target.
Return ? Construct(target, args, newTarget).

9.4.1.3BoundFunctionCreate ( `targetFunction`, `boundThis`, `boundArgs` )

The 抽象操作 BoundFunctionCreate with arguments targetFunction, boundThis and boundArgs is used to specify the creation of new 绑定函数外来对象. It 执行如下:

Assert: Type(targetFunction) is Object.
Let proto be ? targetFunction.[[GetPrototypeOf]]().
Let obj be a newly created object.
Set obj's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set obj.[[Call]] as described in 9.4.1.1.
If IsConstructor(targetFunction) is true, then
1. Set obj.[[Construct]] as described in 9.4.1.2.
Set obj.[[Prototype]] to proto.
Set obj.[[Extensible]] to true.
Set obj.[[BoundTargetFunction]] to targetFunction.
Set obj.[[BoundThis]] to boundThis.
Set obj.[[BoundArguments]] to boundArgs.
Return obj.

9.4.2Array 外来对象

An Array object is an 外来对象 that gives special treatment to array index 属性键 (see 6.1.7). A property whose 属性名 is an array index is also called an element. Every Array object has a length property whose value is always 一个非负整数 less than 2³². The value of the length property is numerically greater than the name of every 自身属性 whose name is an array index; whenever an 自身属性 of an Array object is created or changed, other properties are adjusted as necessary to maintain this invariant. Specifically, whenever an 自身属性 is added whose name is an array index, the value of the length property is changed, if necessary, to be one more than the 数字值 of that array index; and whenever the value of the length property is changed, every 自身属性 whose name is an array index whose value is not smaller than the new length is deleted. This constraint applies only to 自身属性 of an Array object and is unaffected by length or array index properties that may be inherited from its prototypes.

Note

A String 属性名 P is an array index if and only if ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal to 2³²-1.

Array 外来对象 always have a non-configurable property named "length".

Array 外来对象 provide an alternative definition for the [[DefineOwnProperty]] 内部方法. Except for that 内部方法, Array 外来对象 provide all of the other essential 内部方法 as specified in 9.1.

9.4.2.1[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of an Array 外来对象 A is called with property key P, and 属性描述符 Desc, 执行如下:

Assert: IsPropertyKey(P) is true.
If P is "length", then
1. Return ? ArraySetLength(A, Desc).
Else if P is an array index, then
1. Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
2. Assert: oldLenDesc will never be undefined or an accessor descriptor because Array 对象 are created with a length 数据属性 that cannot be deleted or reconfigured.
3. Let oldLen be oldLenDesc.[[Value]].
4. Let index be ! ToUint32(P).
5. If index ≥ oldLen and oldLenDesc.[[Writable]] is false, return false.
6. Let succeeded be ! OrdinaryDefineOwnProperty(A, P, Desc).
7. If succeeded is false, return false.
8. If index ≥ oldLen, then
  1. Set oldLenDesc.[[Value]] to index + 1.
  2. Let succeeded be OrdinaryDefineOwnProperty(A, "length", oldLenDesc).
  3. Assert: succeeded is true.
9. Return true.
Return OrdinaryDefineOwnProperty(A, P, Desc).

9.4.2.2ArrayCreate ( `length` [ , `proto` ] )

The 抽象操作 ArrayCreate with argument length (either 0 or a positive integer) and 可选参数 proto is used to specify the creation of new Array 外来对象. It 执行如下:

Assert: length is an integer Number ≥ 0.
If length is -0, set length to +0.
If length>2³²-1, 抛出一个 RangeError 异常.
If proto is not present, set proto to the 内部对象 %ArrayPrototype%.
Let A be a newly created Array 外来对象.
Set A's essential 内部方法 except for [[DefineOwnProperty]] to the default 普通对象 definitions specified in 9.1.
Set A.[[DefineOwnProperty]] as specified in 9.4.2.1.
Set A.[[Prototype]] to proto.
Set A.[[Extensible]] to true.
Perform ! OrdinaryDefineOwnProperty(A, "length", PropertyDescriptor{[[Value]]: length, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Return A.

9.4.2.3ArraySpeciesCreate ( `originalArray`, `length` )

The 抽象操作 ArraySpeciesCreate with arguments originalArray and length is used to specify the creation of a new Array object using a 构造器 function that is derived from originalArray. It 执行如下:

Assert: length is an integer Number ≥ 0.
If length is -0, set length to +0.
Let isArray be ? IsArray(originalArray).
If isArray is false, return ? ArrayCreate(length).
Let C be ? Get(originalArray, "构造器").
If IsConstructor(C) is true, then
1. Let thisRealm be the current Realm Record.
2. Let realmC be ? GetFunctionRealm(C).
3. If thisRealm and realmC are not the same Realm Record, then
  1. If SameValue(C, realmC.[[Intrinsics]].[[%Array%]]) is true, set C to undefined.
If Type(C) is Object, then
1. Set C to ? Get(C, @@species).
2. If C is null, set C to undefined.
If C is undefined, return ? ArrayCreate(length).
If IsConstructor(C) is false, 抛出一个 TypeError 异常.
Return ? Construct(C, « length »).

Note

If originalArray was created using the 标准内置 Array 构造器 for a realm that is not the realm of the 运行时执行上下文, then a new Array is created using the realm of the 运行时执行上下文. This maintains compatibility with Web browsers that have historically had that behaviour for the Array.prototype methods that now are defined using ArraySpeciesCreate.

9.4.2.4ArraySetLength ( `A`, `Desc` )

When the 抽象操作 ArraySetLength is called with an Array 外来对象 A, and 属性描述符 Desc, 执行如下:

If Desc.[[Value]] is absent, then
1. Return OrdinaryDefineOwnProperty(A, "length", Desc).
Let newLenDesc be a copy of Desc.
Let newLen be ? ToUint32(Desc.[[Value]]).
Let numberLen be ? ToNumber(Desc.[[Value]]).
If newLen ≠ numberLen, 抛出一个 RangeError 异常.
Set newLenDesc.[[Value]] to newLen.
Let oldLenDesc be OrdinaryGetOwnProperty(A, "length").
Assert: oldLenDesc will never be undefined or an accessor descriptor because Array 对象 are created with a length 数据属性 that cannot be deleted or reconfigured.
Let oldLen be oldLenDesc.[[Value]].
If newLen ≥ oldLen, then
1. Return OrdinaryDefineOwnProperty(A, "length", newLenDesc).
If oldLenDesc.[[Writable]] is false, return false.
If newLenDesc.[[Writable]] is absent or has the value true, let newWritable be true.
Else,
1. Need to defer setting the [[Writable]] 特性 to false in case any elements cannot be deleted.
2. Let newWritable be false.
3. Set newLenDesc.[[Writable]] to true.
Let succeeded be ! OrdinaryDefineOwnProperty(A, "length", newLenDesc).
If succeeded is false, return false.
Repeat, while newLen < oldLen,
1. Set oldLen to oldLen - 1.
2. Let deleteSucceeded be ! A.[[Delete]](! ToString(oldLen)).
3. If deleteSucceeded is false, then
  1. Set newLenDesc.[[Value]] to oldLen + 1.
  2. If newWritable is false, set newLenDesc.[[Writable]] to false.
  3. Let succeeded be ! OrdinaryDefineOwnProperty(A, "length", newLenDesc).
  4. Return false.
If newWritable is false, then
1. Return OrdinaryDefineOwnProperty(A, "length", PropertyDescriptor{[[Writable]]: false}). This call will always return true.
Return true.

Note

In steps 3 and 4, if Desc.[[Value]] is an object then its valueOf method is called twice. This is legacy behaviour that was specified with this effect starting with the 2^nd Edition of this specification.

9.4.3String 外来对象

A String 对象 is an 外来对象 that encapsulates a String 值 and exposes virtual integer-indexed data properties corresponding to the individual 代码单元 elements of the String 值. String 外来对象 always have a 数据属性 named "length" whose value is the number of 代码单元 elements in the encapsulated String 值. Both the 代码单元 data properties and the "length" property are non-writable and non-configurable.

String 外来对象 have the same 内部属性 as 普通对象. They also have a [[StringData]] 内部属性.

String 外来对象 provide alternative definitions for the following 内部方法. All of the other String 外来对象 essential 内部方法 that are not defined below are as specified in 9.1.

9.4.3.1[[GetOwnProperty]] ( `P` )

When the [[GetOwnProperty]] 内部方法 of a String 外来对象 S is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let desc be OrdinaryGetOwnProperty(S, P).
If desc is not undefined, return desc.
Return ! StringGetOwnProperty(S, P).

9.4.3.2[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of a String 外来对象 S is called with property key P, and 属性描述符 Desc, 执行如下:

Assert: IsPropertyKey(P) is true.
Let stringDesc be ! StringGetOwnProperty(S, P).
If stringDesc is not undefined, then
1. Let extensible be S.[[Extensible]].
2. Return ! IsCompatiblePropertyDescriptor(extensible, Desc, stringDesc).
Return ! OrdinaryDefineOwnProperty(S, P, Desc).

9.4.3.3[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] 内部方法 of a String 外来对象 O is called, 执行如下:

Let keys be a new empty List.
Let str be the String 值 of O.[[StringData]].
Let len be the length of str.
For each integer i starting with 0 such that i < len, in ascending order, do
1. Add ! ToString(i) as the last element of keys.
For each 自身属性 key P of O such that P is an 整数索引 and ToInteger(P) ≥ len, in ascending numeric index order, do
1. Add P as the last element of keys.
For each 自身属性 key P of O such that Type(P) is String and P is not an 整数索引, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
For each 自身属性 key P of O such that Type(P) is Symbol, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
Return keys.

9.4.3.4StringCreate ( `value`, `prototype` )

The 抽象操作 StringCreate with arguments value and prototype is used to specify the creation of new String 外来对象. It 执行如下:

Assert: Type(value) is String.
Let S be a newly created String 外来对象.
Set S.[[StringData]] to value.
Set S's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set S.[[GetOwnProperty]] as specified in 9.4.3.1.
Set S.[[DefineOwnProperty]] as specified in 9.4.3.2.
Set S.[[OwnPropertyKeys]] as specified in 9.4.3.3.
Set S.[[Prototype]] to prototype.
Set S.[[Extensible]] to true.
Let length be the number of 代码单元 elements in value.
Perform ! DefinePropertyOrThrow(S, "length", PropertyDescriptor{[[Value]]: length, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }).
Return S.

9.4.3.5StringGetOwnProperty ( `S`, `P` )

The 抽象操作 StringGetOwnProperty called with arguments S and P 执行如下:

Assert: S is an Object that has a [[StringData]] 内部属性.
Assert: IsPropertyKey(P) is true.
If Type(P) is not String, return undefined.
Let index be ! CanonicalNumericIndexString(P).
If index is undefined, return undefined.
If IsInteger(index) is false, return undefined.
If index = -0, return undefined.
Let str be the String 值 of S.[[StringData]].
Let len be the length of str.
If index < 0 or len ≤ index, return undefined.
Let resultStr be the String 值 of length 1, containing one 代码单元 from str, specifically the 代码单元 at index index.
Return a PropertyDescriptor{[[Value]]: resultStr, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}.

9.4.4Arguments 外来对象

Most ES functions make an arguments object available to their code. Depending upon the characteristics of the function definition, its arguments object is either an 普通对象 or an arguments 外来对象. An arguments 外来对象 is an 外来对象 whose array index properties map to the formal parameters bindings of an invocation of its associated ES function.

Arguments 外来对象 have the same 内部属性 as 普通对象. They also have a [[ParameterMap]] 内部属性. Ordinary arguments objects also have a [[ParameterMap]] 内部属性 whose value is always undefined. For ordinary argument objects the [[ParameterMap]] 内部属性 is only used by Object.prototype.toString (19.1.3.6) to identify them as such.

Arguments 外来对象 provide alternative definitions for the following 内部方法. All of the other arguments 外来对象 essential 内部方法 that are not defined below are as specified in 9.1

Note 1

The integer-indexed data properties of an arguments 外来对象 whose numeric name values are less than the number of formal parameters of the corresponding 函数对象 initially share their values with the corresponding argument bindings in the function's 执行上下文. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an 访问器属性. If the arguments object is an 普通对象, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.

Note 2

The ParameterMap object and its property values are used as a device for specifying the arguments object correspondence to argument bindings. The ParameterMap object and the objects that are the values of its properties are not directly observable from ES 代码. An ES 实现 does not need to actually create or use such objects to implement the specified 语义.

Note 3

Ordinary arguments objects define a non-configurable 访问器属性 named "callee" which throws a TypeError 异常 on access. The "callee" property has a more specific meaning for arguments 外来对象, which are created only for some class of non-strict functions. The definition of this property in the ordinary variant exists to ensure that it is not defined in any other manner by conforming ES implementations.

Note 4

ES implementations of arguments 外来对象 have historically contained an 访问器属性 named "caller". Prior to ES 2017, this specification included the definition of a throwing "caller" property on ordinary arguments objects. Since implementations do not contain this extension any longer, ES 2017 dropped the requirement for a throwing "caller" accessor.

9.4.4.1[[GetOwnProperty]] ( `P` )

The [[GetOwnProperty]] 内部方法 of an arguments 外来对象 when called with a property key P 执行如下:

Let args be the arguments object.
Let desc be OrdinaryGetOwnProperty(args, P).
If desc is undefined, return desc.
Let map be args.[[ParameterMap]].
Let isMapped be ! HasOwnProperty(map, P).
If isMapped is true, then
1. Set desc.[[Value]] to Get(map, P).
Return desc.

9.4.4.2[[DefineOwnProperty]] ( `P`, `Desc` )

The [[DefineOwnProperty]] 内部方法 of an arguments 外来对象 when called with a property key P and 属性描述符 Desc 执行如下:

Let args be the arguments object.
Let map be args.[[ParameterMap]].
Let isMapped be HasOwnProperty(map, P).
Let newArgDesc be Desc.
If isMapped is true and IsDataDescriptor(Desc) is true, then
1. If Desc.[[Value]] is not present and Desc.[[Writable]] is present and its value is false, then
  1. Set newArgDesc to a copy of Desc.
  2. Set newArgDesc.[[Value]] to Get(map, P).
Let allowed be ? OrdinaryDefineOwnProperty(args, P, newArgDesc).
If allowed is false, return false.
If isMapped is true, then
1. If IsAccessorDescriptor(Desc) is true, then
  1. Call map.[[Delete]](P).
2. Else,
  1. If Desc.[[Value]] is present, then
    1. Let setStatus be Set(map, P, Desc.[[Value]], false).
    2. Assert: setStatus is true because formal parameters mapped by argument objects are always writable.
  2. If Desc.[[Writable]] is present and its value is false, then
    1. Call map.[[Delete]](P).
Return true.

9.4.4.3[[Get]] ( `P`, `Receiver` )

The [[Get]] 内部方法 of an arguments 外来对象 when called with a property key P and ES 语言值 Receiver 执行如下:

Let args be the arguments object.
Let map be args.[[ParameterMap]].
Let isMapped be ! HasOwnProperty(map, P).
If isMapped is false, then
1. Return ? OrdinaryGet(args, P, Receiver).
Else map contains a formal parameter mapping for P,
1. Return Get(map, P).

9.4.4.4[[Set]] ( `P`, `V`, `Receiver` )

The [[Set]] 内部方法 of an arguments 外来对象 when called with property key P, value V, and ES 语言值 Receiver 执行如下:

Let args be the arguments object.
If SameValue(args, Receiver) is false, then
1. Let isMapped be false.
Else,
1. Let map be args.[[ParameterMap]].
2. Let isMapped be ! HasOwnProperty(map, P).
If isMapped is true, then
1. Let setStatus be Set(map, P, V, false).
2. Assert: setStatus is true because formal parameters mapped by argument objects are always writable.
Return ? OrdinarySet(args, P, V, Receiver).

9.4.4.5[[Delete]] ( `P` )

The [[Delete]] 内部方法 of an arguments 外来对象 when called with a property key P 执行如下:

Let args be the arguments object.
Let map be args.[[ParameterMap]].
Let isMapped be ! HasOwnProperty(map, P).
Let result be ? OrdinaryDelete(args, P).
If result is true and isMapped is true, then
1. Call map.[[Delete]](P).
Return result.

9.4.4.6CreateUnmappedArgumentsObject ( `argumentsList` )

The 抽象操作 CreateUnmappedArgumentsObject called with an argument argumentsList 执行如下:

Let len be the number of elements in argumentsList.
Let obj be ObjectCreate(%ObjectPrototype%, « [[ParameterMap]] »).
Set obj.[[ParameterMap]] to undefined.
Perform DefinePropertyOrThrow(obj, "length", PropertyDescriptor{[[Value]]: len, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}).
Let index be 0.
Repeat, while index < len,
1. Let val be argumentsList[index].
2. Perform CreateDataProperty(obj, ! ToString(index), val).
3. Let index be index + 1.
Perform ! DefinePropertyOrThrow(obj, @@迭代器, PropertyDescriptor {[[Value]]: %ArrayProto_values%, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}).
Perform ! DefinePropertyOrThrow(obj, "callee", PropertyDescriptor {[[Get]]: %ThrowTypeError%, [[Set]]: %ThrowTypeError%, [[Enumerable]]: false, [[Configurable]]: false}).
Return obj.

9.4.4.7CreateMappedArgumentsObject ( `func`, `formals`, `argumentsList`, `env` )

The 抽象操作 CreateMappedArgumentsObject is called with object func, 解析节点 formals, List argumentsList, and 环境记录 env. The following steps are performed:

Assert: formals does not contain a rest parameter, any binding 模式, or any 初始化器. It may contain duplicate 标识符.
Let len be the number of elements in argumentsList.
Let obj be a newly created arguments 外来对象 with a [[ParameterMap]] 内部属性.
Set obj.[[GetOwnProperty]] as specified in 9.4.4.1.
Set obj.[[DefineOwnProperty]] as specified in 9.4.4.2.
Set obj.[[Get]] as specified in 9.4.4.3.
Set obj.[[Set]] as specified in 9.4.4.4.
Set obj.[[Delete]] as specified in 9.4.4.5.
Set the remainder of obj's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set obj.[[Prototype]] to %ObjectPrototype%.
Set obj.[[Extensible]] to true.
Let map be ObjectCreate(null).
Set obj.[[ParameterMap]] to map.
Let parameterNames be the 绑定名 of formals.
Let numberOfParameters be the number of elements in parameterNames.
Let index be 0.
Repeat, while index < len,
1. Let val be argumentsList[index].
2. Perform CreateDataProperty(obj, ! ToString(index), val).
3. Let index be index + 1.
Perform DefinePropertyOrThrow(obj, "length", PropertyDescriptor{[[Value]]: len, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}).
Let mappedNames be a new empty List.
Let index be numberOfParameters - 1.
Repeat, while index ≥ 0,
1. Let name be parameterNames[index].
2. If name is not an element of mappedNames, then
  1. Add name as an element of the list mappedNames.
  2. If index < len, then
    1. Let g be MakeArgGetter(name, env).
    2. Let p be MakeArgSetter(name, env).
    3. Perform map.[[DefineOwnProperty]](! ToString(index), PropertyDescriptor{[[Set]]: p, [[Get]]: g, [[Enumerable]]: false, [[Configurable]]: true}).
3. Let index be index - 1.
Perform ! DefinePropertyOrThrow(obj, @@迭代器, PropertyDescriptor {[[Value]]: %ArrayProto_values%, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}).
Perform ! DefinePropertyOrThrow(obj, "callee", PropertyDescriptor {[[Value]]: func, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}).
Return obj.

9.4.4.7.1MakeArgGetter ( `name`, `env` )

The 抽象操作 MakeArgGetter called with String name and 环境记录 env creates a 内置函数对象 that when executed returns the value bound for name in env. It 执行如下:

Let steps be the steps of an ArgGetter function as specified below.
Let getter be CreateBuiltinFunction(steps, « [[Name]], [[Env]] »).
Set getter.[[Name]] to name.
Set getter.[[Env]] to env.
Return getter.

An ArgGetter function is an anonymous 内置函数 with [[Name]] and [[Env]] 内部属性. When an ArgGetter function f that expects no arguments is called it 执行如下:

Let name be f.[[Name]].
Let env be f.[[Env]].
Return env.GetBindingValue(name, false).

Note

ArgGetter functions are never directly accessible to ES 代码.

9.4.4.7.2MakeArgSetter ( `name`, `env` )

The 抽象操作 MakeArgSetter called with String name and 环境记录 env creates a 内置函数对象 that when executed sets the value bound for name in env. It 执行如下:

Let steps be the steps of an ArgSetter function as specified below.
Let setter be CreateBuiltinFunction(steps, « [[Name]], [[Env]] »).
Set setter.[[Name]] to name.
Set setter.[[Env]] to env.
Return setter.

An ArgSetter function is an anonymous 内置函数 with [[Name]] and [[Env]] 内部属性. When an ArgSetter function f is called with argument value it 执行如下:

Let name be f.[[Name]].
Let env be f.[[Env]].
Return env.SetMutableBinding(name, value, false).

Note

ArgSetter functions are never directly accessible to ES 代码.

9.4.5Integer-Indexed 外来对象

An Integer-Indexed 外来对象 is an 外来对象 that performs special handling of 整数索引属性键.

Integer-Indexed 外来对象 have the same 内部属性 as 普通对象 and additionally [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] 内部属性.

Integer-Indexed 外来对象 provide alternative definitions for the following 内部方法. All of the other Integer-Indexed 外来对象 essential 内部方法 that are not defined below are as specified in 9.1.

9.4.5.1[[GetOwnProperty]] ( `P` )

When the [[GetOwnProperty]] 内部方法 of an Integer-Indexed 外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Assert: O is an Object that has a [[ViewedArrayBuffer]] 内部属性.
If Type(P) is String, then
1. Let numericIndex be ! CanonicalNumericIndexString(P).
2. If numericIndex is not undefined, then
  1. Let value be ? IntegerIndexedElementGet(O, numericIndex).
  2. If value is undefined, return undefined.
  3. Return a PropertyDescriptor{[[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false}.
Return OrdinaryGetOwnProperty(O, P).

9.4.5.2[[HasProperty]]( `P` )

When the [[HasProperty]] 内部方法 of an Integer-Indexed 外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Assert: O is an Object that has a [[ViewedArrayBuffer]] 内部属性.
If Type(P) is String, then
1. Let numericIndex be ! CanonicalNumericIndexString(P).
2. If numericIndex is not undefined, then
  1. Let buffer be O.[[ViewedArrayBuffer]].
  2. If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
  3. If IsInteger(numericIndex) is false, return false.
  4. If numericIndex = -0, return false.
  5. If numericIndex < 0, return false.
  6. If numericIndex ≥ O.[[ArrayLength]], return false.
  7. Return true.
Return ? OrdinaryHasProperty(O, P).

9.4.5.3[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of an Integer-Indexed 外来对象 O is called with property key P, and 属性描述符 Desc, 执行如下:

Assert: IsPropertyKey(P) is true.
Assert: O is an Object that has a [[ViewedArrayBuffer]] 内部属性.
If Type(P) is String, then
1. Let numericIndex be ! CanonicalNumericIndexString(P).
2. If numericIndex is not undefined, then
  1. If IsInteger(numericIndex) is false, return false.
  2. If numericIndex = -0, return false.
  3. If numericIndex < 0, return false.
  4. Let length be O.[[ArrayLength]].
  5. If numericIndex ≥ length, return false.
  6. If IsAccessorDescriptor(Desc) is true, return false.
  7. If Desc has a [[Configurable]] field and if Desc.[[Configurable]] is true, return false.
  8. If Desc has an [[Enumerable]] field and if Desc.[[Enumerable]] is false, return false.
  9. If Desc has a [[Writable]] field and if Desc.[[Writable]] is false, return false.
  10. If Desc has a [[Value]] field, then
    1. Let value be Desc.[[Value]].
    2. Return ? IntegerIndexedElementSet(O, numericIndex, value).
  11. Return true.
Return ! OrdinaryDefineOwnProperty(O, P, Desc).

9.4.5.4[[Get]] ( `P`, `Receiver` )

When the [[Get]] 内部方法 of an Integer-Indexed 外来对象 O is called with property key P and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
If Type(P) is String, then
1. Let numericIndex be ! CanonicalNumericIndexString(P).
2. If numericIndex is not undefined, then
  1. Return ? IntegerIndexedElementGet(O, numericIndex).
Return ? OrdinaryGet(O, P, Receiver).

9.4.5.5[[Set]] ( `P`, `V`, `Receiver` )

When the [[Set]] 内部方法 of an Integer-Indexed 外来对象 O is called with property key P, value V, and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
If Type(P) is String, then
1. Let numericIndex be ! CanonicalNumericIndexString(P).
2. If numericIndex is not undefined, then
  1. Return ? IntegerIndexedElementSet(O, numericIndex, V).
Return ? OrdinarySet(O, P, V, Receiver).

9.4.5.6[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] 内部方法 of an Integer-Indexed 外来对象 O is called, 执行如下:

Let keys be a new empty List.
Assert: O is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] 内部属性.
Let len be O.[[ArrayLength]].
For each integer i starting with 0 such that i < len, in ascending order, do
1. Add ! ToString(i) as the last element of keys.
For each 自身属性 key P of O such that Type(P) is String and P is not an 整数索引, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
For each 自身属性 key P of O such that Type(P) is Symbol, in ascending chronological order of property creation, do
1. Add P as the last element of keys.
Return keys.

9.4.5.7IntegerIndexedObjectCreate ( `prototype`, `internalSlotsList` )

The 抽象操作 IntegerIndexedObjectCreate with arguments prototype and internalSlotsList is used to specify the creation of new Integer-Indexed 外来对象. The argument internalSlotsList is a List of the names of additional 内部属性 that must be defined as part of the object. IntegerIndexedObjectCreate 执行如下:

Assert: internalSlotsList contains the names [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]].
Let A be a newly created object with an 内部属性 for each name in internalSlotsList.
Set A's essential 内部方法 to the default 普通对象 definitions specified in 9.1.
Set A.[[GetOwnProperty]] as specified in 9.4.5.1.
Set A.[[HasProperty]] as specified in 9.4.5.2.
Set A.[[DefineOwnProperty]] as specified in 9.4.5.3.
Set A.[[Get]] as specified in 9.4.5.4.
Set A.[[Set]] as specified in 9.4.5.5.
Set A.[[OwnPropertyKeys]] as specified in 9.4.5.6.
Set A.[[Prototype]] to prototype.
Set A.[[Extensible]] to true.
Return A.

9.4.5.8IntegerIndexedElementGet ( `O`, `index` )

The 抽象操作 IntegerIndexedElementGet with arguments O and index 执行如下:

Assert: Type(index) is Number.
Assert: O is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
If IsInteger(index) is false, return undefined.
If index = -0, return undefined.
Let length be O.[[ArrayLength]].
If index < 0 or index ≥ length, return undefined.
Let offset be O.[[ByteOffset]].
Let arrayTypeName be the String 值 of O.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let indexedPosition be (index × elementSize) + offset.
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Return GetValueFromBuffer(buffer, indexedPosition, elementType, true, "Unordered").

9.4.5.9IntegerIndexedElementSet ( `O`, `index`, `value` )

The 抽象操作 IntegerIndexedElementSet with arguments O, index, and value 执行如下:

Assert: Type(index) is Number.
Assert: O is an Object that has [[ViewedArrayBuffer]], [[ArrayLength]], [[ByteOffset]], and [[TypedArrayName]] 内部属性.
Let numValue be ? ToNumber(value).
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
If IsInteger(index) is false, return false.
If index = -0, return false.
Let length be O.[[ArrayLength]].
If index < 0 or index ≥ length, return false.
Let offset be O.[[ByteOffset]].
Let arrayTypeName be the String 值 of O.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let indexedPosition be (index × elementSize) + offset.
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Perform SetValueInBuffer(buffer, indexedPosition, elementType, numValue, true, "Unordered").
Return true.

9.4.6Module 命名空间外来对象

A 模块命名空间对象 is an 外来对象 that exposes the bindings exported from an ES Module (See 15.2.3). There is a one-to-one correspondence between the String-keyed 自身属性 of a module 命名空间外来对象 and the binding names exported by the Module. The exported bindings include any bindings that are indirectly exported using export * export items. Each String-valued 自身属性 key is the 字符值 of the corresponding exported binding name. These are the only String-keyed properties of a module 命名空间外来对象. Each such property has the 特性 { [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false }. 模块命名空间对象 are not extensible.

模块命名空间对象 have the 内部属性 defined in Table 29.

Table 29: 内部属性 of Module 命名空间外来对象

内部属性	Type	Description
[[Module]]	Module Record	The Module Record whose exports this 命名空间 exposes.
[[Exports]]	List of String	A List containing the String values of the exported names exposed as 自身属性 of this object. The list is ordered as if an Array of those String values had been sorted using `Array.prototype.sort` using undefined as `comparefn`.
[[Prototype]]	Null	This slot always contains the value null (see 9.4.6.1).

Module 命名空间外来对象 provide alternative definitions for all of the 内部方法 except [[GetPrototypeOf]], which behaves as defined in 9.1.1.

9.4.6.1[[SetPrototypeOf]] ( `V` )

When the [[SetPrototypeOf]] 内部方法 of a module 命名空间外来对象 O is called with argument V, 执行如下:

Return ? SetImmutablePrototype(O, V).

9.4.6.2[[IsExtensible]] ( )

When the [[IsExtensible]] 内部方法 of a module 命名空间外来对象 O is called, 执行如下:

Return false.

9.4.6.3[[PreventExtensions]] ( )

When the [[PreventExtensions]] 内部方法 of a module 命名空间外来对象 O is called, 执行如下:

Return true.

9.4.6.4[[GetOwnProperty]] ( `P` )

When the [[GetOwnProperty]] 内部方法 of a module 命名空间外来对象 O is called with property key P, 执行如下:

If Type(P) is Symbol, return OrdinaryGetOwnProperty(O, P).
Let exports be O.[[Exports]].
If P is not an element of exports, return undefined.
Let value be ? O.[[Get]](P, O).
Return PropertyDescriptor{[[Value]]: value, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: false }.

9.4.6.5[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of a module 命名空间外来对象 O is called with property key P and 属性描述符 Desc, 执行如下:

Return false.

9.4.6.6[[HasProperty]] ( `P` )

When the [[HasProperty]] 内部方法 of a module 命名空间外来对象 O is called with property key P, 执行如下:

If Type(P) is Symbol, return OrdinaryHasProperty(O, P).
Let exports be O.[[Exports]].
If P is an element of exports, return true.
Return false.

9.4.6.7[[Get]] ( `P`, `Receiver` )

When the [[Get]] 内部方法 of a module 命名空间外来对象 O is called with property key P and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
If Type(P) is Symbol, then
1. Return ? OrdinaryGet(O, P, Receiver).
Let exports be O.[[Exports]].
If P is not an element of exports, return undefined.
Let m be O.[[Module]].
Let binding be ! m.ResolveExport(P, « »).
Assert: binding is a ResolvedBinding Record.
Let targetModule be binding.[[Module]].
Assert: targetModule is not undefined.
Let targetEnv be targetModule.[[Environment]].
If targetEnv is undefined, 抛出一个 ReferenceError 异常.
Let targetEnvRec be targetEnv's EnvironmentRecord.
Return ? targetEnvRec.GetBindingValue(binding.[[BindingName]], true).

Note

ResolveExport is idempotent and side-effect free. An 实现 might choose to pre-compute or cache the ResolveExport results for the [[Exports]] of each module 命名空间外来对象.

9.4.6.8[[Set]] ( `P`, `V`, `Receiver` )

When the [[Set]] 内部方法 of a module 命名空间外来对象 O is called with property key P, value V, and ES 语言值 Receiver, 执行如下:

Return false.

9.4.6.9[[Delete]] ( `P` )

When the [[Delete]] 内部方法 of a module 命名空间外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
If Type(P) is Symbol, then
1. Return ? OrdinaryDelete(O, P).
Let exports be O.[[Exports]].
If P is an element of exports, return false.
Return true.

9.4.6.10[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] 内部方法 of a module 命名空间外来对象 O is called, 执行如下:

Let exports be a copy of O.[[Exports]].
Let symbolKeys be ! OrdinaryOwnPropertyKeys(O).
Append all the entries of symbolKeys to the end of exports.
Return exports.

9.4.6.11ModuleNamespaceCreate ( `module`, `exports` )

The 抽象操作 ModuleNamespaceCreate with arguments module, and exports is used to specify the creation of new module 命名空间外来对象. It 执行如下:

Assert: module is a Module Record.
Assert: module.[[命名空间]] is undefined.
Assert: exports is a List of String values.
Let M be a newly created object.
Set M's essential 内部方法 to the definitions specified in 9.4.6.
Set M.[[Module]] to module.
Let sortedExports be a new List containing the same values as the list exports where the values are ordered as if an Array of the same values had been sorted using Array.prototype.sort using undefined as comparefn.
Set M.[[Exports]] to sortedExports.
Create 自身属性 of M corresponding to the definitions in 26.3.
Set module.[[命名空间]] to M.
Return M.

9.4.7Immutable Prototype 外来对象

An immutable prototype 外来对象 is an 外来对象 that has a [[Prototype]] 内部属性 that will not change once it is initialized.

Immutable prototype 外来对象 have the same 内部属性 as 普通对象. They are exotic only in the following 内部方法. All other 内部方法 of immutable prototype 外来对象 that are not explicitly defined below are instead defined as in 普通对象.

9.4.7.1[[SetPrototypeOf]] ( `V` )

When the [[SetPrototypeOf]] 内部方法 of an immutable prototype 外来对象 O is called with argument V, 执行如下:

Return ? SetImmutablePrototype(O, V).

9.4.7.2SetImmutablePrototype ( `O`, `V` )

When the SetImmutablePrototype 抽象操作 is called with arguments O and V, 执行如下:

Assert: Either Type(V) is Object or Type(V) is Null.
Let current be ? O.[[GetPrototypeOf]]().
If SameValue(V, current) is true, return true.
Return false.

9.5Proxy 对象内部方法和内部属性

A 代理对象 is an 外来对象 whose essential 内部方法 are partially implemented using ES 代码. Every Proxy 对象 has an 内部属性 called [[ProxyHandler]]. The value of [[ProxyHandler]] is an object, called the proxy's handler object, or null. Methods (see Table 30) of a handler object may be used to augment the 实现 for one or more of the 代理对象's 内部方法. Every 代理对象 also has an 内部属性 called [[ProxyTarget]] whose value is either an object or the null value. This object is called the proxy's target object.

Table 30: Proxy Handler Methods

内部方法	Handler Method
[[GetPrototypeOf]]	`getPrototypeOf`
[[SetPrototypeOf]]	`setPrototypeOf`
[[IsExtensible]]	`isExtensible`
[[PreventExtensions]]	`preventExtensions`
[[GetOwnProperty]]	`getOwnPropertyDescriptor`
[[DefineOwnProperty]]	`defineProperty`
[[HasProperty]]	`has`
[[Get]]	`get`
[[Set]]	`set`
[[Delete]]	`deleteProperty`
[[OwnPropertyKeys]]	`ownKeys`
[[Call]]	`apply`
[[Construct]]	`construct`

When a handler method is called to provide the 实现 of a 代理对象内部方法, the handler method is passed the proxy's target object as a parameter. A proxy's handler object does not necessarily have a method corresponding to every essential 内部方法. Invoking an 内部方法 on the proxy results in the invocation of the corresponding 内部方法 on the proxy's target object if the handler object does not have a method corresponding to the internal trap.

The [[ProxyHandler]] and [[ProxyTarget]] 内部属性 of a 代理对象 are always initialized when the object is created and typically may not be modified. Some Proxy 对象 are created in a manner that permits them to be subsequently revoked. When a proxy is revoked, its [[ProxyHandler]] and [[ProxyTarget]] 内部属性 are set to null causing subsequent invocations of 内部方法 on that 代理对象 to 抛出一个 TypeError 异常.

Because Proxy 对象 permit the 实现 of 内部方法 to be provided by arbitrary ES 代码, it is possible to define a 代理对象 whose handler methods violates the 不变量 defined in 6.1.7.3. Some of the 内部方法不变量 defined in 6.1.7.3 are essential integrity 不变量. These 不变量 are explicitly enforced by the 代理对象内部方法 specified in this section. An ES 实现 must be robust in the presence of all possible invariant violations.

In the following 算法 descriptions, assume O is an ES 代理对象, P is a property key value, V is any ES 语言值 and Desc is a 属性描述符 record.

9.5.1[[GetPrototypeOf]] ( )

When the [[GetPrototypeOf]] 内部方法 of a Proxy 外来对象 O is called, 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "getPrototypeOf").
If trap is undefined, then
1. Return ? target.[[GetPrototypeOf]]().
Let handlerProto be ? Call(trap, handler, « target »).
If Type(handlerProto) is neither Object nor Null, 抛出一个 TypeError 异常.
Let extensibleTarget be ? IsExtensible(target).
If extensibleTarget is true, return handlerProto.
Let targetProto be ? target.[[GetPrototypeOf]]().
If SameValue(handlerProto, targetProto) is false, 抛出一个 TypeError 异常.
Return handlerProto.

Note

[[GetPrototypeOf]] for Proxy 对象 enforces the following 不变量:

The result of [[GetPrototypeOf]] must be either an Object or null.
If the target object is not extensible, [[GetPrototypeOf]] applied to the 代理对象 must return the same value as [[GetPrototypeOf]] applied to the 代理对象's target object.

9.5.2[[SetPrototypeOf]] ( `V` )

When the [[SetPrototypeOf]] 内部方法 of a Proxy 外来对象 O is called with argument V, 执行如下:

Assert: Either Type(V) is Object or Type(V) is Null.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "setPrototypeOf").
If trap is undefined, then
1. Return ? target.[[SetPrototypeOf]](V).
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target, V »)).
If booleanTrapResult is false, return false.
Let extensibleTarget be ? IsExtensible(target).
If extensibleTarget is true, return true.
Let targetProto be ? target.[[GetPrototypeOf]]().
If SameValue(V, targetProto) is false, 抛出一个 TypeError 异常.
Return true.

Note

[[SetPrototypeOf]] for Proxy 对象 enforces the following 不变量:

The result of [[SetPrototypeOf]] is a Boolean 值.
If the target object is not extensible, the argument value must be the same as the result of [[GetPrototypeOf]] applied to target object.

9.5.3[[IsExtensible]] ( )

When the [[IsExtensible]] 内部方法 of a Proxy 外来对象 O is called, 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "isExtensible").
If trap is undefined, then
1. Return ? target.[[IsExtensible]]().
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target »)).
Let targetResult be ? target.[[IsExtensible]]().
If SameValue(booleanTrapResult, targetResult) is false, 抛出一个 TypeError 异常.
Return booleanTrapResult.

Note

[[IsExtensible]] for Proxy 对象 enforces the following 不变量:

The result of [[IsExtensible]] is a Boolean 值.
[[IsExtensible]] applied to the 代理对象 must return the same value as [[IsExtensible]] applied to the 代理对象's target object with the same argument.

9.5.4[[PreventExtensions]] ( )

When the [[PreventExtensions]] 内部方法 of a Proxy 外来对象 O is called, 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "preventExtensions").
If trap is undefined, then
1. Return ? target.[[PreventExtensions]]().
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target »)).
If booleanTrapResult is true, then
1. Let targetIsExtensible be ? target.[[IsExtensible]]().
2. If targetIsExtensible is true, 抛出一个 TypeError 异常.
Return booleanTrapResult.

Note

[[PreventExtensions]] for Proxy 对象 enforces the following 不变量:

The result of [[PreventExtensions]] is a Boolean 值.
[[PreventExtensions]] applied to the 代理对象 only returns true if [[IsExtensible]] applied to the 代理对象's target object is false.

9.5.5[[GetOwnProperty]] ( `P` )

When the [[GetOwnProperty]] 内部方法 of a Proxy 外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "getOwnPropertyDescriptor").
If trap is undefined, then
1. Return ? target.[[GetOwnProperty]](P).
Let trapResultObj be ? Call(trap, handler, « target, P »).
If Type(trapResultObj) is neither Object nor Undefined, 抛出一个 TypeError 异常.
Let targetDesc be ? target.[[GetOwnProperty]](P).
If trapResultObj is undefined, then
1. If targetDesc is undefined, return undefined.
2. If targetDesc.[[Configurable]] is false, 抛出一个 TypeError 异常.
3. Let extensibleTarget be ? IsExtensible(target).
4. Assert: Type(extensibleTarget) is Boolean.
5. If extensibleTarget is false, 抛出一个 TypeError 异常.
6. Return undefined.
Let extensibleTarget be ? IsExtensible(target).
Let resultDesc be ? ToPropertyDescriptor(trapResultObj).
Call CompletePropertyDescriptor(resultDesc).
Let valid be IsCompatiblePropertyDescriptor(extensibleTarget, resultDesc, targetDesc).
If valid is false, 抛出一个 TypeError 异常.
If resultDesc.[[Configurable]] is false, then
1. If targetDesc is undefined or targetDesc.[[Configurable]] is true, then
  1. 抛出一个 TypeError 异常.
Return resultDesc.

Note

[[GetOwnProperty]] for Proxy 对象 enforces the following 不变量:

The result of [[GetOwnProperty]] must be either an Object or undefined.
A property cannot be reported as non-existent, if it exists as a non-configurable 自身属性 of the target object.
A property cannot be reported as non-existent, if it exists as an 自身属性 of the target object and the target object is not extensible.
A property cannot be reported as existent, if it does not exist as an 自身属性 of the target object and the target object is not extensible.
A property cannot be reported as non-configurable, if it does not exist as an 自身属性 of the target object or if it exists as a configurable 自身属性 of the target object.

9.5.6[[DefineOwnProperty]] ( `P`, `Desc` )

When the [[DefineOwnProperty]] 内部方法 of a Proxy 外来对象 O is called with property key P and 属性描述符 Desc, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "defineProperty").
If trap is undefined, then
1. Return ? target.[[DefineOwnProperty]](P, Desc).
Let descObj be FromPropertyDescriptor(Desc).
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target, P, descObj »)).
If booleanTrapResult is false, return false.
Let targetDesc be ? target.[[GetOwnProperty]](P).
Let extensibleTarget be ? IsExtensible(target).
If Desc has a [[Configurable]] field and if Desc.[[Configurable]] is false, then
1. Let settingConfigFalse be true.
Else, let settingConfigFalse be false.
If targetDesc is undefined, then
1. If extensibleTarget is false, 抛出一个 TypeError 异常.
2. If settingConfigFalse is true, 抛出一个 TypeError 异常.
Else targetDesc is not undefined,
1. If IsCompatiblePropertyDescriptor(extensibleTarget, Desc, targetDesc) is false, 抛出一个 TypeError 异常.
2. If settingConfigFalse is true and targetDesc.[[Configurable]] is true, 抛出一个 TypeError 异常.
Return true.

Note

[[DefineOwnProperty]] for Proxy 对象 enforces the following 不变量:

The result of [[DefineOwnProperty]] is a Boolean 值.
A property cannot be added, if the target object is not extensible.
A property cannot be non-configurable, unless there exists a corresponding non-configurable 自身属性 of the target object.
If a property has a corresponding target object property then applying the 属性描述符 of the property to the target object using [[DefineOwnProperty]] will not 抛出一个异常.

9.5.7[[HasProperty]] ( `P` )

When the [[HasProperty]] 内部方法 of a Proxy 外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "has").
If trap is undefined, then
1. Return ? target.[[HasProperty]](P).
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target, P »)).
If booleanTrapResult is false, then
1. Let targetDesc be ? target.[[GetOwnProperty]](P).
2. If targetDesc is not undefined, then
  1. If targetDesc.[[Configurable]] is false, 抛出一个 TypeError 异常.
  2. Let extensibleTarget be ? IsExtensible(target).
  3. If extensibleTarget is false, 抛出一个 TypeError 异常.
Return booleanTrapResult.

Note

[[HasProperty]] for Proxy 对象 enforces the following 不变量:

The result of [[HasProperty]] is a Boolean 值.
A property cannot be reported as non-existent, if it exists as a non-configurable 自身属性 of the target object.
A property cannot be reported as non-existent, if it exists as an 自身属性 of the target object and the target object is not extensible.

9.5.8[[Get]] ( `P`, `Receiver` )

When the [[Get]] 内部方法 of a Proxy 外来对象 O is called with property key P and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "get").
If trap is undefined, then
1. Return ? target.[[Get]](P, Receiver).
Let trapResult be ? Call(trap, handler, « target, P, Receiver »).
Let targetDesc be ? target.[[GetOwnProperty]](P).
If targetDesc is not undefined and targetDesc.[[Configurable]] is false, then
1. If IsDataDescriptor(targetDesc) is true and targetDesc.[[Writable]] is false, then
  1. If SameValue(trapResult, targetDesc.[[Value]]) is false, 抛出一个 TypeError 异常.
2. If IsAccessorDescriptor(targetDesc) is true and targetDesc.[[Get]] is undefined, then
  1. If trapResult is not undefined, 抛出一个 TypeError 异常.
Return trapResult.

Note

[[Get]] for Proxy 对象 enforces the following 不变量:

The value reported for a property must be the same as the value of the corresponding target object property if the target object property is a non-writable, non-configurable own 数据属性.
The value reported for a property must be undefined if the corresponding target object property is a non-configurable own 访问器属性 that has undefined as its [[Get]] 特性.

9.5.9[[Set]] ( `P`, `V`, `Receiver` )

When the [[Set]] 内部方法 of a Proxy 外来对象 O is called with property key P, value V, and ES 语言值 Receiver, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "set").
If trap is undefined, then
1. Return ? target.[[Set]](P, V, Receiver).
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target, P, V, Receiver »)).
If booleanTrapResult is false, return false.
Let targetDesc be ? target.[[GetOwnProperty]](P).
If targetDesc is not undefined and targetDesc.[[Configurable]] is false, then
1. If IsDataDescriptor(targetDesc) is true and targetDesc.[[Writable]] is false, then
  1. If SameValue(V, targetDesc.[[Value]]) is false, 抛出一个 TypeError 异常.
2. If IsAccessorDescriptor(targetDesc) is true, then
  1. If targetDesc.[[Set]] is undefined, 抛出一个 TypeError 异常.
Return true.

Note

[[Set]] for Proxy 对象 enforces the following 不变量:

The result of [[Set]] is a Boolean 值.
Cannot change the value of a property to be different from the value of the corresponding target object property if the corresponding target object property is a non-writable, non-configurable own 数据属性.
Cannot set the value of a property if the corresponding target object property is a non-configurable own 访问器属性 that has undefined as its [[Set]] 特性.

9.5.10[[Delete]] ( `P` )

When the [[Delete]] 内部方法 of a Proxy 外来对象 O is called with property key P, 执行如下:

Assert: IsPropertyKey(P) is true.
Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "deleteProperty").
If trap is undefined, then
1. Return ? target.[[Delete]](P).
Let booleanTrapResult be ToBoolean(? Call(trap, handler, « target, P »)).
If booleanTrapResult is false, return false.
Let targetDesc be ? target.[[GetOwnProperty]](P).
If targetDesc is undefined, return true.
If targetDesc.[[Configurable]] is false, 抛出一个 TypeError 异常.
Return true.

Note

[[Delete]] for Proxy 对象 enforces the following 不变量:

The result of [[Delete]] is a Boolean 值.
A property cannot be reported as deleted, if it exists as a non-configurable 自身属性 of the target object.

9.5.11[[OwnPropertyKeys]] ( )

When the [[OwnPropertyKeys]] 内部方法 of a Proxy 外来对象 O is called, 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "ownKeys").
If trap is undefined, then
1. Return ? target.[[OwnPropertyKeys]]().
Let trapResultArray be ? Call(trap, handler, « target »).
Let trapResult be ? CreateListFromArrayLike(trapResultArray, « String, Symbol »).
If trapResult contains any duplicate entries, 抛出一个 TypeError 异常.
Let extensibleTarget be ? IsExtensible(target).
Let targetKeys be ? target.[[OwnPropertyKeys]]().
Assert: targetKeys is a List containing only String and Symbol 值.
Assert: targetKeys contains no duplicate entries.
Let targetConfigurableKeys be a new empty List.
Let targetNonconfigurableKeys be a new empty List.
For each element key of targetKeys, do
1. Let desc be ? target.[[GetOwnProperty]](key).
2. If desc is not undefined and desc.[[Configurable]] is false, then
  1. Append key as an element of targetNonconfigurableKeys.
3. Else,
  1. Append key as an element of targetConfigurableKeys.
If extensibleTarget is true and targetNonconfigurableKeys is empty, then
1. Return trapResult.
Let uncheckedResultKeys be a new List which is a copy of trapResult.
For each key that is an element of targetNonconfigurableKeys, do
1. If key is not an element of uncheckedResultKeys, 抛出一个 TypeError 异常.
2. Remove key from uncheckedResultKeys.
If extensibleTarget is true, return trapResult.
For each key that is an element of targetConfigurableKeys, do
1. If key is not an element of uncheckedResultKeys, 抛出一个 TypeError 异常.
2. Remove key from uncheckedResultKeys.
If uncheckedResultKeys is not empty, 抛出一个 TypeError 异常.
Return trapResult.

Note

[[OwnPropertyKeys]] for Proxy 对象 enforces the following 不变量:

The result of [[OwnPropertyKeys]] is a List.
The returned List contains no duplicate entries.
The Type of each result List element is either String or Symbol.
The result List must contain the keys of all non-configurable 自身属性 of the target object.
If the target object is not extensible, then the result List must contain all the keys of the 自身属性 of the target object and no other values.

9.5.12[[Call]] ( `thisArgument`, `argumentsList` )

The [[Call]] 内部方法 of a Proxy 外来对象 O is called with parameters thisArgument and argumentsList, a List of ES 语言值. 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "apply").
If trap is undefined, then
1. Return ? Call(target, thisArgument, argumentsList).
Let argArray be CreateArrayFromList(argumentsList).
Return ? Call(trap, handler, « target, thisArgument, argArray »).

Note

A Proxy 外来对象 only has a [[Call]] 内部方法 if the 初始值 of its [[ProxyTarget]] 内部属性 is an object that has a [[Call]] 内部方法.

9.5.13[[Construct]] ( `argumentsList`, `newTarget` )

The [[Construct]] 内部方法 of a Proxy 外来对象 O is called with parameters argumentsList which is a possibly empty List of ES 语言值 and newTarget. 执行如下:

Let handler be O.[[ProxyHandler]].
If handler is null, 抛出一个 TypeError 异常.
Assert: Type(handler) is Object.
Let target be O.[[ProxyTarget]].
Let trap be ? GetMethod(handler, "construct").
If trap is undefined, then
1. Assert: IsConstructor(target) is true.
2. Return ? Construct(target, argumentsList, newTarget).
Let argArray be CreateArrayFromList(argumentsList).
Let newObj be ? Call(trap, handler, « target, argArray, newTarget »).
If Type(newObj) is not Object, 抛出一个 TypeError 异常.
Return newObj.

Note 1

A Proxy 外来对象 only has a [[Construct]] 内部方法 if the 初始值 of its [[ProxyTarget]] 内部属性 is an object that has a [[Construct]] 内部方法.

Note 2

[[Construct]] for Proxy 对象 enforces the following 不变量:

The result of [[Construct]] must be an Object.

9.5.14ProxyCreate ( `target`, `handler` )

The 抽象操作 ProxyCreate with arguments target and handler is used to specify the creation of new Proxy 外来对象. It 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
If target is a Proxy 外来对象 and target.[[ProxyHandler]] is null, 抛出一个 TypeError 异常.
If Type(handler) is not Object, 抛出一个 TypeError 异常.
If handler is a Proxy 外来对象 and handler.[[ProxyHandler]] is null, 抛出一个 TypeError 异常.
Let P be a newly created object.
Set P's essential 内部方法 (except for [[Call]] and [[Construct]]) to the definitions specified in 9.5.
If IsCallable(target) is true, then
1. Set P.[[Call]] as specified in 9.5.12.
2. If IsConstructor(target) is true, then
  1. Set P.[[Construct]] as specified in 9.5.13.
Set P.[[ProxyTarget]] to target.
Set P.[[ProxyHandler]] to handler.
Return P.

10ES：源代码

10.1源文本

句法

any Unicode code point

ES 的代码是由 Unicode 编码的。ES 的源文本就是一串码点序列。范围在 U+0000 到 U+10FFFF 内的所有 Unicode 码点值，包括代理码点，都可能在被 ES 文法所认可的源文本中出现。被用来存储和交换 ES 源文本的实际的编码是和本规范无关的。抛开外部源文本编码不说，一个一致性的 ES 实现处理源文本就像是把它等价于 SourceCharacter 值的序列一样，每个 SourceCharacter 是一个 Unicode 码点。一致性的 ES 实现并不需要实现任何源文本的正规化，或是表现出它们是被正规化了一样。

一个结合在一起的字符序列组件会被当做一个单独的 Unicode 码点对待，尽管用户可能会把整个序列看做是一个单独的字符。

Note

在字符串字面量、正则表达式字面量、模板字面量还有标识符中，任何的 Unicode 码点也可能会使用 Unicode 转译序列来表达，Unicode 转译序列会显式地表达出一个码点的数字值。在评论中，这样的一个转译序列会被作为评论的一部分给忽略掉。

在 Unicode 转译序列的行为上，ES 不同于 Java 语言。例如，在一个 Java 程序中，如果这个 Unicode 转译序列 \u000A 出现在一个单行注释中，那么它会被解释成一个行终止符（Unicode 码点 \u000A 是一个行补（LINE FEED，LF）），且从下一个码点开始的码点就不在是该单行注释的一部分了。同样的，如果这个 Unicode 转译序列 \u000A 出现在一个 Java 程序的的字符串字面量中，它也会被看做一个行终止符，即不允许出现在一个字符换字面量中，但如果用 \n 来代替 \u000A 的话，会使一个行补（LINE FEED，LF）），成为字符串字面量的一部分。在一个 ES 程序中，如果一个评论中出现了一个 Unicode 转译序列，那么该转译序列是不会被解释的，所以不会导致一个评论的终结。同样的，在 ES 程序中，如果一个字符串字面量中出现了一个 Unicode 转移序列，该转译序列也同样不被解释为一个行终止符或者一个可能导致字符串字面量终结的码点。

10.1.1静态: UTF16Encoding ( `cp` )

一个数值码点值（cp）的 UTF16Encoding 判定如下：

Assert: 0 ≤ cp ≤ 0x10FFFF.
If cp ≤ 0xFFFF, return cp.
Let cu1 be floor((cp - 0x10000) / 0x400) + 0xD800.
Let cu2 be ((cp - 0x10000) modulo 0x400) + 0xDC00.
Return the 代码单元 sequence consisting of cu1 followed by cu2.

10.1.2静态语义: UTF16Decode( `lead`, `trail` )

Two 代码单元, lead and trail, that form a UTF-16 代理对 are converted to a 码点 by performing the following steps:

Assert: 0xD800 ≤ lead ≤ 0xDBFF and 0xDC00 ≤ trail ≤ 0xDFFF.
Let cp be (lead - 0xD800) × 0x400 + (trail - 0xDC00) + 0x10000.
Return the 码点 cp.

10.2源代码类型

ES 代码有四种类型：

全局代码 被看做是一种 ES 脚本的源文本。一个特定脚本的全局代码不包含任何被解析成以下部分的源文本：一个 FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, MethodDefinition, ArrowFunction, AsyncArrowFunction, ClassDeclaration, or ClassExpression。
Eval 代码是指提供给内置 eval 函数的源文本。更准确地说，如果内置 eval 函数的参数为一个字符串，那么该字符串将被看做是 ES 脚本。一个特定 eval 调用的 eval 代码是脚本的全局代码部分。
函数代码是指解析用来提供一个 ES 函数对象的内部属性(见 9.2) [[ECMAScriptCode]] 和 [[FormalParameters]] 的值。一个特定的 ES 函数的函数代码不包括任何以下被解析为函数代码的源文本：a nested FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, MethodDefinition, ArrowFunction, AsyncArrowFunction, ClassDeclaration, or ClassExpression.
模块是指被提供用来作为一个模块体的源文本。当一个模块被初始化时，该代码会被直接评估。一个特定模块的模块代码不包括任何被解析为以下部分的源文本： a nested FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, MethodDefinition, ArrowFunction, AsyncArrowFunction, ClassDeclaration, or ClassExpression。

Note

Function code is generally provided as the bodies of 函数定义 (14.1), 箭头函数定义 (14.2), 方法定义 (14.3), 生成器函数定义 (14.4), 异步函数定义 (14.7), 异步生成器函数定义 (14.5), and Async Arrow Functions (14.8). Function code is also derived from the arguments to the Function 构造器 (19.2.1.1), the GeneratorFunction 构造器 (25.2.1.1), and the AsyncFunction 构造器 (25.7.1.1).

10.2.1严格模式代码

一个 ES 脚本句法单元可以使用非严格或严格模式下的句法及语义进行处理。在一些情况中，代码会被作为严格模式代码来解释：

如果全局代码以一个包含使用严格指令（Use Strict Directive）的指令序言（Directive Prologue）作为开始时，其是严格模式代码。
模块代码始终处于严格模式下。
所有 ClassDeclaration 或者 ClassExpression 的部分都是严格模式代码。
Eval code is 严格模式代码 if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval that is contained in 严格模式代码.
Function code is 严格模式代码 if the associated FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, MethodDefinition, ArrowFunction, or AsyncArrowFunction is contained in 严格模式代码 or if the code that produces the value of the function's [[ECMAScriptCode]] 内部属性 begins with a Directive Prologue that contains a Use Strict Directive.
Function code that is supplied as the arguments to the 内置 Function, Generator, AsyncFunction, and AsyncGenerator constructors is 严格模式代码 if the last argument is a String that when processed is a FunctionBody that begins with a Directive Prologue that contains a Use Strict Directive.

不是严格模式代码的 ES 代码叫做非严格代码。

10.2.2非 ES 函数

An ES 实现 may support the 估值 of function 外来对象 whose evaluative behaviour is expressed in some 实现-defined form of executable code other than via ES 代码. Whether a 函数对象 is an ES 代码 function or a non-ES function is not semantically observable from the perspective of an ES 代码 function that calls or is called by such a non-ES function.

11ES 语言: 词法

一个 ES 脚本或模块的源文本会先被转换为输入元素的一个序列，即 tokens、行终止符、评论、或空白。该源文本会被从左到右扫描，反复地将最长的可能码点序列作为下一个输入元素。

有几种情况，词法输入元素的识别对消耗输入元素的语义上的文法上下文是敏感的。这需要多个目标符用于词汇文法。当一个RegularExpressionLiteral, a TemplateMiddle, 或 a TemplateTail 被允许时，目标符 InputElementRegExpOrTemplateTail 可以用于语义上的文法上下文。当a RegularExpressionLiteral 被允许但a TemplateMiddle 和 a TemplateTail 都不被允许时，目标符 InputElementRegExp 可以被用于所有的语义上的文法上下文。InputElementTemplateTail 当 a TemplateMiddle or a TemplateTail 被允许但 a RegularExpressionLiteral 不被允许时，目标符可以用于所有的语义上的文法上下文。在所有其它的上下文中，InputElementDiv 会被用作词法目标符。

Note

多个 lexical goals 的使用确保了没有词法上的歧义会影响到自动分号的插入。例如, there are no syntactic grammar contexts where both a leading division or division-assignment, and a leading RegularExpressionLiteral are permitted. 这是不会被分号插入影响到的（见 11.9）；例如

a = b
            /hi/g.exec(c).map(d);

where the first non-whitespace, non-comment 码点 after a LineTerminator is U+002F (SOLIDUS) and the syntactic context allows division or division-assignment, no semicolon is inserted at the LineTerminator. 即，上述例子会以下面的方式被解释；

a = b / hi / g.exec(c).map(d);

Syntax

InputElementRegExpOrTemplateTail

InputElementTemplateTail

11.1Unicode 格式控制字符

The Unicode 格式控制字符 (i.e., the characters in category “Cf” in the Unicode Character Database 例如 LEFT-TO-RIGHT MARK or RIGHT-TO-LEFT MARK) are control codes used to control the formatting of a range of text in the absence of higher-level protocols for this (例如 mark-up languages).

It is useful to allow format-control characters in 源文本 to facilitate editing and display. All format control characters may be used within 评论, and within 字符型字面量, 模板字面量, and 正则表达式字面量.

U+200C (ZERO WIDTH NON-JOINER) and U+200D (ZERO WIDTH JOINER) are format-control characters that are used to make necessary distinctions when forming words or phrases in certain languages. In ES 源文本 these code points may also be used in an IdentifierName after the first character.

U+FEFF (ZERO WIDTH NO-BREAK SPACE) is a format-control character used primarily at the start of a text to mark it as Unicode and to allow detection of the text's encoding and byte order. <ZWNBSP> characters intended for this purpose can sometimes also appear after the start of a text, 例如 as a result of concatenating files. In ES 源文本 <ZWNBSP> code points are treated as 空白 characters (see 11.2).

The special treatment of certain format-control characters outside of 评论, 字符型字面量, and 正则表达式字面量 is summarized in Table 31.

Table 31: Format-Control 码点 Usage

码点	Name	Abbreviation	Usage
`U+200C`	ZERO WIDTH NON-JOINER	<ZWNJ>	IdentifierPart
`U+200D`	ZERO WIDTH JOINER	<ZWJ>	IdentifierPart
`U+FEFF`	ZERO WIDTH NO-BREAK SPACE	<ZWNBSP>	WhiteSpace

11.2空白

空白码点用来提高源文本的可读性和分割 tokens（不可分割的词法单元），此外就无关紧要。空白码点可以出现在任一两个 token 之间和一个在输入的开始或结束位置。空白码点可以出现在 a StringLiteral, a RegularExpressionLiteral, a Template, or a TemplateSubstitutionTail 中。它们也可以出现在一个评论中，但是不能出现在任何其它类型的 token 内部。

ES 空白码点被列在表 32中。

表 32: 空白码点

码点	Name	Abbreviation
`U+0009`	（水平）制表符（CHARACTER TABULATION）	<TAB>
`U+000B`	垂直制表符（LINE TABULATION）	<VT>
`U+000C`	换页符（FORM FEED ，FF）	<FF>
`U+0020`	空格符（SPACE）	<SP>
`U+00A0`	不中断空格（NO-BREAK SPACE）	<NBSP>
`U+FEFF`	零宽度不中断空格（ZERO WIDTH NO-BREAK SPACE）	<ZWNBSP>
Other category “Zs”	Any other Unicode “Space_Separator” 码点	<USP>

ES 实现必须能够识别列在“Space_Separator” (“Zs”) 类别中的空格码点。

Note

除了列在表 32 中的码点，ES 空格有意地排除了所有有 Unicode “White_Space” 属性但没有被类别 “Space_Separator” (“Zs”) 划分的码点。

Syntax

WhiteSpace

<TAB>

<VT>

<FF>

<SP>

<NBSP>

<USP>

11.3行终止符

如空白码点一样，行终止字符码点用于提高源文本的可读性和分割 tokens（不可分割的词法单元）。然而，不像空白码点，行终止符对句法文法的行为有一定的影响。一般情况下，行终止符可以出现在任何两个 token 之间，但也有少数地方，句法文法禁止这样做。行终止符也会影响自动分号插入的过程（11.9）。行终止符不能出现在除了a StringLiteral, Template, or TemplateSubstitutionTail 之外的任何 token 内部。行终止符或许只能出现在作为 a LineContinuation 一部分的 a StringLiteral token 里。

行终止符可以出现在一个 MultiLineComment 内部，但不能出现在一个 SingleLineComment 内部。

行终止符被包含在空白码点集合中，可以用正则表达式 \s 来匹配。

表 33 中列出了 ES 行终止符码点。

表 33: 行分隔符码点

码点	Unicode Name	Abbreviation
`U+000A`	行补（LINE FEED，LF，换行）	<LF>
`U+000D`	回车（CARRIAGE RETURN，CR）	<CR>
`U+2028`	行分隔符（LINE SEPARATOR）	<LS>
`U+2029`	段落分隔符（PARAGRAPH SEPARATOR）	<PS>

只有在表 33 中的 Unicode 码点才能被看做行终止符。其它的新行或断行 Unicode 码点不能被看做行终止符，但如果满足表 32 中列出的要求，可以将其视为空白。序列 <CR><LF> 通常用被作行终止符。它应该被视为一个单独的 SourceCharacter，以便于报告行数。

Syntax

LineTerminator

<LF>

<CR>

<LS>

<PS>

<LF>

<CR>

[lookahead ≠ <LF>]

<LS>

<PS>

<CR>

<LF>

11.4注释

注释可以是单行或多行。多行注释不能嵌套。

因为单行注释可以包含除了 LineTerminator 码点之外的任何 Unicode 码点，又因为有这个普遍的规则：一个 token 总是尽可能地匹配更长，所以一个单行注释总是包含从 // 标志到行尾之间的所有码点。然而，在该行尾的 LineTerminator 不被认为是单行注释的一部分，它会被词法单独地识别并且成为句法输入元素流的一部分。这一点非常重要，因为这意味着是否存在单行注释都不会影响自动分号插入的过程（见 11.9）。

像空白一样，注释会被句法简单丢弃，除了 MultiLineComment 包含行终止符码点的情况，这种情况下整个注释会被当作一个 LineTerminator 以便于句法解析。

Syntax

opt

opt

opt

opt

opt

but not *

but not one of / or *

SingleLineComment

opt

opt

but not LineTerminator

11.5Tokens

Syntax

Note

The DivPunctuator, RegularExpressionLiteral, RightBracePunctuator, and TemplateSubstitutionTail productions derive additional tokens that are not included in the CommonToken production.

11.6名字和关键字

IdentifierName 和 ReservedWord 是根据 Unicode 标准附录 #31，标识符和模式句法，中给出的默认标识符句法进行解释的 tokens，并进行了一些小的修改。ReservedWord 是 IdentifierName 的枚举子集。句法将 Identifier 定义为一个不是 ReservedWord 的 IdentifierName。 Unicode 标识符文法基于 Unicode 标准指定的字符属性。在最新版本 Unicode 标准中的指定类别中的 Unicode 码点，必须按照所有符合 ES 实现的那些类别进行处理。 ES 实现可以识别在 Unicode 标准的后期版本中定义的标识符码点。

Note 1

该标准规定了特定的码点添加物：在标识符名称的任何地方允许存在 U+0024（美元符号）和 U+005F（下划线），并且 U+200C（零宽度无连接符）和 U+200D（零宽度连接符）码点被允许在 IdentifierName 的第一个码点之后的任何地方。

Unicode 转义序列允许在 IdentifierName 中被使用，它们会将一个单独的 Unicode 码点贡献给 IdentifierName。码点由 UnicodeEscapeSequence (见 11.8.4) 的 CodePoint 表示。\（UnicodeEscapeSequence 之前的）以及 u 和 { } 代码单元（如果它们出现）不会将码点贡献给 IdentifierName。UnicodeEscapeSequence 不能用于将一个码点放入一个 IdentifierName 中，因为这是非法的。换句话说，如果一个 \ UnicodeEscapeSequence 序列被它所贡献的 SourceCharacter 替换，结果必须仍然是一个有效的 IdentifierName，它与原始的 IdentifierName 具有完全相同的 SourceCharacter 元素序列。本规范中 IdentifierName 的所有解释都基于它们的实际码点，而不管转义序列是否用于贡献任何特定的码点。

除非在每个 UnicodeEscapeSequence 被替换之后，它们由完全相同的码点序列表示，否则根据 Unicode 标准的两个 IdentifierNames 是不相等的。

Syntax

<ZWNJ>

<ZWJ>

UnicodeIDStart

any Unicode 码点 with the Unicode property “ID_Start”

any Unicode 码点 with the Unicode property “ID_Continue”

The definitions of the nonterminal UnicodeEscapeSequence is given in 11.8.4.

Note 2

The nonterminal IdentifierPart derives _ via UnicodeIDContinue.

Note 3

The sets of code points with Unicode properties “ID_Start” and “ID_Continue” include, respectively, the code points with Unicode properties “Other_ID_Start” and “Other_ID_Continue”.

11.6.1标识符名

11.6.1.1静态语义: 早期错误

IdentifierStart

这是一个句法错误如果 SV(UnicodeEscapeSequence) is none of "$", or "_", or the UTF16Encoding of a 码点 matched by the UnicodeIDStart 词法 production.

这是一个句法错误如果 SV(UnicodeEscapeSequence) is none of "$", or "_", or the UTF16Encoding of either <ZWNJ> or <ZWJ>, or the UTF16Encoding of a Unicode 码点 that would be matched by the UnicodeIDContinue 词法 production.

11.6.1.2静态语义: 字符值

返回由 IdentifierName 对应的代码单元序列组成的字符串值。在确定序列的过程中，任何出现的 \ UnicodeEscapeSequence 首先被 UnicodeEscapeSequence 代表的码点替换，然后通过 UTF16Encoding 编码每个代码点，将整个 IdentifierName 的码点转换为代码单元。

11.6.2保留字

保留字是一个不能用作 Identifier 的 IdentifierName。

Syntax

Note

The ReservedWord definitions are specified as literal sequences of specific SourceCharacter elements. A 码点 in a ReservedWord cannot be expressed by a \ UnicodeEscapeSequence.

11.6.2.1关键字

以下的 tokens 是 ES 关键字，不能用作 ES 程序中的 Identifiers。

Syntax

Keyword

one of

await

break

case

catch

class

const

continue

debugger

default

delete

else

export

extends

finally

for

function

import

instanceof

new

return

super

switch

this

throw

try

typeof

var

void

while

with

yield

Note

In some contexts yield and await are given the 语义 of an Identifier. See 12.1.1. In 严格模式代码, let and static are treated as 保留字 through static semantic restrictions (see 12.1.1, 13.3.1.1, 13.7.5.1, and 14.6.1) rather than the 词法.

11.6.2.2未来保留字

以下 tokens 会被保留来用作未来语言扩展中的关键字。

Syntax

FutureReservedWord

enum

Note

在严格模式代码中以下 tokens 的使用也是被保留的。该用法受静态语义限制（见 12.1.1）的限制，而不是词法：

`implements`	`package`	`protected`
`interface`	`private`	`public`

11.7标点符号

Syntax

Punctuator

one of

{

(

)

[

]

...

;

===

!==

>>>

**=

<<=

>>=

>>>=

DivPunctuator

RightBracePunctuator

}

11.8字面量

11.8.1Null 字面量

Syntax

NullLiteral

null

11.8.2布尔型字面量

Syntax

BooleanLiteral

true

false

11.8.3数值型字面量

Syntax

opt

opt

opt

ExponentPart

opt

opt

one of

one of

one of

one of

one of

one of

The SourceCharacter immediately following a NumericLiteral must not be an IdentifierStart or DecimalDigit.

Note

例如：3in 是一个错误，不存在两个输入元素 3 和 in。

A conforming 实现, when processing 严格模式代码, must not extend, as described in B.1.1, the syntax of NumericLiteral to include LegacyOctalIntegerLiteral, nor extend the syntax of DecimalIntegerLiteral to include NonOctalDecimalIntegerLiteral.

11.8.3.1静态语义: MV

一个数值型字面量代表一个 Number 类型的值。此值取决于两个步骤：第一，由字面量得出的数学值（MV）；第二，这个数学值按照后面描述的规则舍入。

The MV of NumericLiteral::DecimalLiteral is the MV of DecimalLiteral.
The MV of NumericLiteral::BinaryIntegerLiteral is the MV of BinaryIntegerLiteral.
The MV of NumericLiteral::OctalIntegerLiteral is the MV of OctalIntegerLiteral.
The MV of NumericLiteral::HexIntegerLiteral is the MV of HexIntegerLiteral.
The MV of DecimalLiteral::DecimalIntegerLiteral. is the MV of DecimalIntegerLiteral.
The MV of DecimalLiteral::DecimalIntegerLiteral.DecimalDigits is the MV of DecimalIntegerLiteral plus (the MV of DecimalDigits × 10^-n), where n is the number of code points in DecimalDigits.
The MV of DecimalLiteral::DecimalIntegerLiteral.ExponentPart is the MV of DecimalIntegerLiteral × 10^e, where e is the MV of ExponentPart.
The MV of DecimalLiteral::DecimalIntegerLiteral.DecimalDigitsExponentPart is (the MV of DecimalIntegerLiteral plus (the MV of DecimalDigits × 10^-n)) × 10^e, where n is the number of code points in DecimalDigits and e is the MV of ExponentPart.
The MV of DecimalLiteral::.DecimalDigits is the MV of DecimalDigits × 10^-n, where n is the number of code points in DecimalDigits.
The MV of DecimalLiteral::.DecimalDigitsExponentPart is the MV of DecimalDigits × 10^e-n, where n is the number of code points in DecimalDigits and e is the MV of ExponentPart.
The MV of DecimalLiteral::DecimalIntegerLiteral is the MV of DecimalIntegerLiteral.
The MV of DecimalLiteral::DecimalIntegerLiteralExponentPart is the MV of DecimalIntegerLiteral × 10^e, where e is the MV of ExponentPart.
The MV of DecimalIntegerLiteral::0 is 0.
The MV of DecimalIntegerLiteral::NonZeroDigit is the MV of NonZeroDigit.
The MV of DecimalIntegerLiteral::NonZeroDigitDecimalDigits is (the MV of NonZeroDigit × 10ⁿ) plus the MV of DecimalDigits, where n is the number of code points in DecimalDigits.
The MV of DecimalDigits::DecimalDigit is the MV of DecimalDigit.
The MV of DecimalDigits::DecimalDigitsDecimalDigit is (the MV of DecimalDigits × 10) plus the MV of DecimalDigit.
The MV of ExponentPart::ExponentIndicatorSignedInteger is the MV of SignedInteger.
The MV of SignedInteger::DecimalDigits is the MV of DecimalDigits.
The MV of SignedInteger::+DecimalDigits is the MV of DecimalDigits.
The MV of SignedInteger::-DecimalDigits is the negative of the MV of DecimalDigits.
The MV of DecimalDigit::0 or of HexDigit::0 or of OctalDigit::0 or of BinaryDigit::0 is 0.
The MV of DecimalDigit::1 or of NonZeroDigit::1 or of HexDigit::1 or of OctalDigit::1 or of BinaryDigit::1 is 1.
The MV of DecimalDigit::2 or of NonZeroDigit::2 or of HexDigit::2 or of OctalDigit::2 is 2.
The MV of DecimalDigit::3 or of NonZeroDigit::3 or of HexDigit::3 or of OctalDigit::3 is 3.
The MV of DecimalDigit::4 or of NonZeroDigit::4 or of HexDigit::4 or of OctalDigit::4 is 4.
The MV of DecimalDigit::5 or of NonZeroDigit::5 or of HexDigit::5 or of OctalDigit::5 is 5.
The MV of DecimalDigit::6 or of NonZeroDigit::6 or of HexDigit::6 or of OctalDigit::6 is 6.
The MV of DecimalDigit::7 or of NonZeroDigit::7 or of HexDigit::7 or of OctalDigit::7 is 7.
The MV of DecimalDigit::8 or of NonZeroDigit::8 or of HexDigit::8 is 8.
The MV of DecimalDigit::9 or of NonZeroDigit::9 or of HexDigit::9 is 9.
The MV of HexDigit::a or of HexDigit::A is 10.
The MV of HexDigit::b or of HexDigit::B is 11.
The MV of HexDigit::c or of HexDigit::C is 12.
The MV of HexDigit::d or of HexDigit::D is 13.
The MV of HexDigit::e or of HexDigit::E is 14.
The MV of HexDigit::f or of HexDigit::F is 15.
The MV of BinaryIntegerLiteral::0bBinaryDigits is the MV of BinaryDigits.
The MV of BinaryIntegerLiteral::0BBinaryDigits is the MV of BinaryDigits.
The MV of BinaryDigits::BinaryDigit is the MV of BinaryDigit.
The MV of BinaryDigits::BinaryDigitsBinaryDigit is (the MV of BinaryDigits × 2) plus the MV of BinaryDigit.
The MV of OctalIntegerLiteral::0oOctalDigits is the MV of OctalDigits.
The MV of OctalIntegerLiteral::0OOctalDigits is the MV of OctalDigits.
The MV of OctalDigits::OctalDigit is the MV of OctalDigit.
The MV of OctalDigits::OctalDigitsOctalDigit is (the MV of OctalDigits × 8) plus the MV of OctalDigit.
The MV of HexIntegerLiteral::0xHexDigits is the MV of HexDigits.
The MV of HexIntegerLiteral::0XHexDigits is the MV of HexDigits.
The MV of HexDigits::HexDigit is the MV of HexDigit.
The MV of HexDigits::HexDigitsHexDigit is (the MV of HexDigits × 16) plus the MV of HexDigit.

数值型字面量的确切 MV 值一旦被确定，它就会舍入成 Number 类型的值。如果 MV 是 0，那么舍入值是 +0；否则，舍入值必须是 MV 对应的准确数字值（定义在 6.1.6 中），除非此字面量是一个有效数字超过 20 位的 DecimalLiteral，这种情况下，数字值可以用下面两种方式产生的 MV 值确定：一，将 20 位后的每个有效数字用 0 替换后产生的 MV，二，将 20 位后的每个有效数字用 0 替换，并且递增第 20 位有效数字位置的字面量值，产生的 MV。如果一个数字不是 ExponentPart 的一部分，那么它是一个有效数字，并且

它不是 0；或
它的左侧是非零数字，它的右侧是不在 ExponentPart 中的非零数字。

11.8.4字符型字面量

Note 1

字符型字面量是由单引号或双引号包围的零个或多个 Unicode 码点。Unicode 码点也可以用一个转义序列表示。除了用来闭合的引号码点，反斜线（U+005C，REVERSE SOLIDUS），回车（U+000D，CARRIAGE RETURN），行分隔符（U+2028，LINE SEPARATOR），段落分隔符（U+2029，PARAGRAPH SEPARATOR），行补（U+000A ，LINE FEED）之外的所有码点都可以出现的字符型字面量里。任何码点都可以以转义序列的形式出现。字符型字面量会估测 ES 字符串值。当生成这些字符串值的 Unicode 码点是由 UTF-16 编码（定义在 10.1.1）的时，属于 Basic Multilingual Plane 的码点会以一个单独的字符串的代码单元元素被编码。而所有其它类型的码点会以字符串的两个代码单元元素被编码。

Syntax

opt

opt

opt

opt

but not one of " or \ or LineTerminator

but not one of ' or \ or LineTerminator

[lookahead ∉ DecimalDigit]

A conforming 实现, when processing 严格模式代码, must not extend the syntax of EscapeSequence to include LegacyOctalEscapeSequence as described in B.1.2.

one of

but not one of EscapeCharacter or LineTerminator

EscapeCharacter

}

The definition of the nonterminal HexDigit is given in 11.8.3. SourceCharacter is defined in 10.1.

Note 2

行终止符码点不能出现在一个字符型字面量中，除非作为生成空码点序列的 LineContinuation 的一部分。使行终止符码点成为字符型字面量的字符串值的一部分的正确方法是使用转义序列，例如 \n 或 \u000A。

11.8.4.1静态语义: 字符值

opt

opt

Return the String 值 whose elements are the SV of this StringLiteral.

11.8.4.2静态语义: SV

一个字符型字面量代表 String 类型的一个值。字面量的字符串值 (SV) （就码点值而言）是由字符型字面量的各部分贡献的码点值所描述。作为这一过程的一部分，字符型字面量里的某些 Unicode 码点会被解释成包含一个数学值 (MV)，如 11.8.3 或下面的描述。

The SV of StringLiteral::"" is the empty 代码单元 sequence.
The SV of StringLiteral::'' is the empty 代码单元 sequence.
The SV of StringLiteral::"DoubleStringCharacters" is the SV of DoubleStringCharacters.
The SV of StringLiteral::'SingleStringCharacters' is the SV of SingleStringCharacters.
The SV of DoubleStringCharacters::DoubleStringCharacter is a sequence of up to two 代码单元 that is the SV of DoubleStringCharacter.
The SV of DoubleStringCharacters::DoubleStringCharacterDoubleStringCharacters is a sequence of up to two 代码单元 that is the SV of DoubleStringCharacter followed by the 代码单元 of the SV of DoubleStringCharacters in order.
The SV of SingleStringCharacters::SingleStringCharacter is a sequence of up to two 代码单元 that is the SV of SingleStringCharacter.
The SV of SingleStringCharacters::SingleStringCharacterSingleStringCharacters is a sequence of up to two 代码单元 that is the SV of SingleStringCharacter followed by the 代码单元 of the SV of SingleStringCharacters in order.
The SV of DoubleStringCharacter::SourceCharacterbut not one of " or \ or LineTerminator is the UTF16Encoding of the 码点 value of SourceCharacter.
The SV of DoubleStringCharacter::\EscapeSequence is the SV of the EscapeSequence.
The SV of DoubleStringCharacter::LineContinuation is the empty 代码单元 sequence.
The SV of SingleStringCharacter::SourceCharacterbut not one of ' or \ or LineTerminator is the UTF16Encoding of the 码点 value of SourceCharacter.
The SV of SingleStringCharacter::\EscapeSequence is the SV of the EscapeSequence.
The SV of SingleStringCharacter::LineContinuation is the empty 代码单元 sequence.
The SV of EscapeSequence::CharacterEscapeSequence is the SV of the CharacterEscapeSequence.
The SV of EscapeSequence::0 is the 代码单元 0x0000 (NULL).
The SV of EscapeSequence::HexEscapeSequence is the SV of the HexEscapeSequence.
The SV of EscapeSequence::UnicodeEscapeSequence is the SV of the UnicodeEscapeSequence.
The SV of CharacterEscapeSequence::SingleEscapeCharacter is the 代码单元 whose value is determined by the SingleEscapeCharacter according to Table 34.

表 34: 字符串单字符转义序列

转义序列	码点值	Unicode 字符名	符号
`\b`	`0x0008`	空格（BACKSPACE）	<BS>
`\t`	`0x0009`	水平制表符（CHARACTER TABULATION）	<HT>
`\n`	`0x000A`	行补（LINE FEED ，LF）	<LF>
`\v`	`0x000B`	垂直制表符（LINE TABULATION）	<VT>
`\f`	`0x000C`	换页（FORM FEED ，FF）	<FF>
`\r`	`0x000D`	回车（CARRIAGE RETURN ，CR）	<CR>
`\"`	`0x0022`	双引号（QUOTATION MARK）	`"`
`\'`	`0x0027`	单引号（APOSTROPHE）	`'`
`\\`	`0x005C`	反斜线（REVERSE SOLIDUS）	`\`

The SV of CharacterEscapeSequence::NonEscapeCharacter is the SV of the NonEscapeCharacter.
The SV of NonEscapeCharacter::SourceCharacterbut not one of EscapeCharacter or LineTerminator is the UTF16Encoding of the 码点 value of SourceCharacter.
The SV of HexEscapeSequence::xHexDigitHexDigit is the 代码单元 whose value is (16 times the MV of the first HexDigit) plus the MV of the second HexDigit.
The SV of UnicodeEscapeSequence::uHex4Digits is the SV of Hex4Digits.
The SV of Hex4Digits::HexDigitHexDigitHexDigitHexDigit is the 代码单元 whose value is (0x1000 times the MV of the first HexDigit) plus (0x100 times the MV of the second HexDigit) plus (0x10 times the MV of the third HexDigit) plus the MV of the fourth HexDigit.
The SV of UnicodeEscapeSequence::u{CodePoint} is the UTF16Encoding of the MV of CodePoint.

11.8.5正则表达式字面量

Note 1

正则表达式字面量是输入元素，每当字面量被评估时，该输入元素都会转换为 RegExp 对象（见 21.2）。当一个程序中有两个正则表达式字面量被评估成正则表达式对象时，即使两个字面量包含相同内容，也不能用 === 比较他们是否相等。RegExp 对象也可以在运行时使用 new RegExp 或以函数方式调用 RegExp 构造器来创建（见 21.2.3）。

下面的生成式描述了正则表达式字面量的语法，并且输入元素扫描器还用它来搜索正则表达式字面量的结束位置。包含 RegularExpressionBody 和 RegularExpressionFlags 的源文本随后会再次被使用了更严格的 ES 正则表达式文法（21.2.1）解析。

实现可能会扩展定义在 21.2.1 中的 ES 正则表达式文法，但是它不会扩展下面定义的 RegularExpressionBody 和 RegularExpressionFlags 生成式，或者使用这些生成式的生成式。

Syntax

[empty]

but not one of * or \ or / or [

but not one of \ or / or [

but not LineTerminator

[

]

[empty]

RegularExpressionClassChar

but not one of ] or \

[empty]

Note 2

正则表达式字面量 may not be empty; instead of representing an empty 正则表达式 literal, the 代码单元 sequence // starts a single-line comment. To specify an empty 正则表达式, use: /(?:)/.正则表达式字面量不能为空；并不是说正则表达式字面量不能代表空，码点序列 // 会启动一个单行注释。要指定一个空正则表达式，使用：/(?:)/。

11.8.5.1静态语义: 早期错误

这是一个句法错误如果 IdentifierPart contains a Unicode escape sequence.

11.8.5.2静态语义: BodyText

Return the 源文本 that was recognized as RegularExpressionBody.

11.8.5.3静态语义: FlagText

Return the 源文本 that was recognized as RegularExpressionFlags.

11.8.6模板字面量词法组件

Syntax

Template

opt

opt

}

opt

}

opt

opt

[lookahead ≠ {]

but not one of ` or \ or $ or LineTerminator

NotEscapeSequence

but not 0

[lookahead ∉ HexDigit]

[lookahead ∉ HexDigit]

[lookahead ≠ {]

[lookahead ∉ HexDigit]

[lookahead ∉ HexDigit]

[lookahead ∉ HexDigit]

{

[lookahead ∉ HexDigit]

{

NotCodePoint

[lookahead ∉ HexDigit]

{

CodePoint

[lookahead ∉ HexDigit]

[lookahead ≠ }]

NotCodePoint

HexDigits

but only if MV of HexDigits > 0x10FFFF

CodePoint

HexDigits

but only if MV of HexDigits ≤ 0x10FFFF

A conforming 实现 must not use the extended definition of EscapeSequence described in B.1.2 when parsing a TemplateCharacter.

Note

TemplateSubstitutionTail is used by the InputElementTemplateTail alternative lexical goal.

11.8.6.1静态语义: TV and TRV

模板字面量组件被解释为一串 Unicode 码点。一个字面量组件的模板值（TV）是由模板字面量组件的各个部分贡献的代码单元值（SV，11.8.4）来描述的。作为该过程的一部分，模板组件中的一些 Unicode 码点被解释为具有数学值（MV，11.8.3）。在确定一个 TV 时，转义序列被转义序列表示的 Unicode 码点的 UTF-16 代码单元替代。模板原始值（TRV）与模板值类似，不同之处在于，TRV 中的转义序列按字面解释的。

The TV and TRV of NoSubstitutionTemplate::`` is the empty 代码单元 sequence.
The TV and TRV of TemplateHead::`${ is the empty 代码单元 sequence.
The TV and TRV of TemplateMiddle::}${ is the empty 代码单元 sequence.
The TV and TRV of TemplateTail::}` is the empty 代码单元 sequence.
The TV of NoSubstitutionTemplate::`TemplateCharacters` is the TV of TemplateCharacters.
The TV of TemplateHead::`TemplateCharacters${ is the TV of TemplateCharacters.
The TV of TemplateMiddle::}TemplateCharacters${ is the TV of TemplateCharacters.
The TV of TemplateTail::}TemplateCharacters` is the TV of TemplateCharacters.
The TV of TemplateCharacters::TemplateCharacter is the TV of TemplateCharacter.
The TV of TemplateCharacters::TemplateCharacterTemplateCharacters is undefined if either the TV of TemplateCharacter is undefined or the TV of TemplateCharacters is undefined. Otherwise, it is a sequence consisting of the 代码单元 of the TV of TemplateCharacter followed by the 代码单元 of the TV of TemplateCharacters.
The TV of TemplateCharacter::SourceCharacterbut not one of ` or \ or $ or LineTerminator is the UTF16Encoding of the 码点 value of SourceCharacter.
The TV of TemplateCharacter::$ is the 代码单元 0x0024 (DOLLAR SIGN).
The TV of TemplateCharacter::\EscapeSequence is the SV of EscapeSequence.
The TV of TemplateCharacter::\NotEscapeSequence is undefined.
The TV of TemplateCharacter::LineContinuation is the TV of LineContinuation.
The TV of TemplateCharacter::LineTerminatorSequence is the TRV of LineTerminatorSequence.
The TV of LineContinuation::\LineTerminatorSequence is the empty 代码单元 sequence.
The TRV of NoSubstitutionTemplate::`TemplateCharacters` is the TRV of TemplateCharacters.
The TRV of TemplateHead::`TemplateCharacters${ is the TRV of TemplateCharacters.
The TRV of TemplateMiddle::}TemplateCharacters${ is the TRV of TemplateCharacters.
The TRV of TemplateTail::}TemplateCharacters` is the TRV of TemplateCharacters.
The TRV of TemplateCharacters::TemplateCharacter is the TRV of TemplateCharacter.
The TRV of TemplateCharacters::TemplateCharacterTemplateCharacters is a sequence consisting of the 代码单元 of the TRV of TemplateCharacter followed by the 代码单元 of the TRV of TemplateCharacters.
The TRV of TemplateCharacter::SourceCharacterbut not one of ` or \ or $ or LineTerminator is the UTF16Encoding of the 码点 value of SourceCharacter.
The TRV of TemplateCharacter::$ is the 代码单元 0x0024 (DOLLAR SIGN).
The TRV of TemplateCharacter::\EscapeSequence is the sequence consisting of the 代码单元 0x005C (REVERSE SOLIDUS) followed by the 代码单元 of TRV of EscapeSequence.
The TRV of TemplateCharacter::\NotEscapeSequence is the sequence consisting of the 代码单元 0x005C (REVERSE SOLIDUS) followed by the 代码单元 of TRV of NotEscapeSequence.
The TRV of TemplateCharacter::LineContinuation is the TRV of LineContinuation.
The TRV of TemplateCharacter::LineTerminatorSequence is the TRV of LineTerminatorSequence.
The TRV of EscapeSequence::CharacterEscapeSequence is the TRV of the CharacterEscapeSequence.
The TRV of EscapeSequence::0 is the 代码单元 0x0030 (DIGIT ZERO).
The TRV of EscapeSequence::HexEscapeSequence is the TRV of the HexEscapeSequence.
The TRV of EscapeSequence::UnicodeEscapeSequence is the TRV of the UnicodeEscapeSequence.
The TRV of NotEscapeSequence::0DecimalDigit is the sequence consisting of the 代码单元 0x0030 (DIGIT ZERO) followed by the 代码单元 of the TRV of DecimalDigit.
The TRV of NotEscapeSequence::x[lookahead ∉ HexDigit] is the 代码单元 0x0078 (LATIN SMALL LETTER X).
The TRV of NotEscapeSequence::xHexDigit[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0078 (LATIN SMALL LETTER X) followed by the 代码单元 of the TRV of HexDigit.
The TRV of NotEscapeSequence::u[lookahead ∉ HexDigit][lookahead ≠ {] is the 代码单元 0x0075 (LATIN SMALL LETTER U).
The TRV of NotEscapeSequence::uHexDigit[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 of the TRV of HexDigit.
The TRV of NotEscapeSequence::uHexDigitHexDigit[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 of the TRV of the first HexDigit followed by the 代码单元 of the TRV of the second HexDigit.
The TRV of NotEscapeSequence::uHexDigitHexDigitHexDigit[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 of the TRV of the first HexDigit followed by the 代码单元 of the TRV of the second HexDigit followed by the 代码单元 of the TRV of the third HexDigit.
The TRV of NotEscapeSequence::u{[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 0x007B (LEFT CURLY BRACKET).
The TRV of NotEscapeSequence::u{NotCodePoint[lookahead ∉ HexDigit] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 0x007B (LEFT CURLY BRACKET) followed by the 代码单元 of the TRV of NotCodePoint.
The TRV of NotEscapeSequence::u{CodePoint[lookahead ∉ HexDigit][lookahead ≠ }] is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 0x007B (LEFT CURLY BRACKET) followed by the 代码单元 of the TRV of CodePoint.
The TRV of DecimalDigit::one of0123456789 is the SV of the SourceCharacter that is that single 码点.
The TRV of CharacterEscapeSequence::SingleEscapeCharacter is the TRV of the SingleEscapeCharacter.
The TRV of CharacterEscapeSequence::NonEscapeCharacter is the SV of the NonEscapeCharacter.
The TRV of SingleEscapeCharacter::one of'"\bfnrtv is the SV of the SourceCharacter that is that single 码点.
The TRV of HexEscapeSequence::xHexDigitHexDigit is the sequence consisting of the 代码单元 0x0078 (LATIN SMALL LETTER X) followed by TRV of the first HexDigit followed by the TRV of the second HexDigit.
The TRV of UnicodeEscapeSequence::uHex4Digits is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by TRV of Hex4Digits.
The TRV of UnicodeEscapeSequence::u{CodePoint} is the sequence consisting of the 代码单元 0x0075 (LATIN SMALL LETTER U) followed by the 代码单元 0x007B (LEFT CURLY BRACKET) followed by TRV of CodePoint followed by the 代码单元 0x007D (RIGHT CURLY BRACKET).
The TRV of Hex4Digits::HexDigitHexDigitHexDigitHexDigit is the sequence consisting of the TRV of the first HexDigit followed by the TRV of the second HexDigit followed by the TRV of the third HexDigit followed by the TRV of the fourth HexDigit.
The TRV of HexDigits::HexDigit is the TRV of HexDigit.
The TRV of HexDigits::HexDigitsHexDigit is the sequence consisting of TRV of HexDigits followed by TRV of HexDigit.
The TRV of a HexDigit is the SV of the SourceCharacter that is that HexDigit.
The TRV of LineContinuation::\LineTerminatorSequence is the sequence consisting of the 代码单元 0x005C (REVERSE SOLIDUS) followed by the 代码单元 of TRV of LineTerminatorSequence.
The TRV of LineTerminatorSequence::<LF> is the 代码单元 0x000A (LINE FEED).
The TRV of LineTerminatorSequence::<CR> is the 代码单元 0x000A (LINE FEED).
The TRV of LineTerminatorSequence::<LS> is the 代码单元 0x2028 (LINE SEPARATOR).
The TRV of LineTerminatorSequence::<PS> is the 代码单元 0x2029 (PARAGRAPH SEPARATOR).
The TRV of LineTerminatorSequence::<CR><LF> is the sequence consisting of the 代码单元 0x000A (LINE FEED).

Note

TV excludes the 代码单元 of LineContinuation while TRV includes them. <CR><LF> and <CR> LineTerminatorSequences are normalized to <LF> for both TV and TRV. An explicit EscapeSequence is needed to include a <CR> or <CR><LF> sequence.

11.9自动分号插入

大多数 ES 语句必须用一个分号终止。这些分号总是明确的显示在源文本里。然而，为了方便起见，某些情况下这些分号可以在源文本里省略。即这些情况下，分号会被自动插入到源代码的 token 流中。

11.9.1自动分号插入的规则

在以下规则中，“token” 是指使用当前词汇目标符（条款 11 中描述的）所确定的实际识别的 lexical token。

分号插入有三个基本规则：

以从左到右的顺序解析源文本，当遇到一个不被任何任何文法生成式所允许的 token（叫做违规 token）时，那么只要满足下面条件之一就会在违规 token 前面自动插入分号。
- 至少一个 LineTerminator分割了违规 token 和前一个 token。
- 违规 token 是 }.
- 在一个 do-while 语句（13.7.2）中，如果前一个 token 是 ) ，那么插入的分号会被解析为一个终止分号。
以从左到右的顺序解析源文本，当 tokens 的输入流被结束，且解析器无法将输入 token 流解析成目标非终止符的单个实例时，那么分号会被自动插入在输入流的结束位置。
When, as the 源文本 is parsed from left to right, a token is encountered that is allowed by some production of the grammar, but the production is a restricted production and the token would be the first token for a terminal or nonterminal immediately following the annotation “[no LineTerminator here]” within the restricted production (and therefore such a token is called a restricted token), and the restricted token is separated from the previous token by at least one LineTerminator, then a semicolon is automatically inserted before the restricted token.

然而，上述规则有一个附加的优先条件：如果插入分号后解析结果是空语句，或插入分号后它成为 for 语句头部的两个分号之一（见 13.7.4），那么将不会自动插入分号。

Note

The following are the only restricted productions in the grammar:

[Yield, Await]

[?Yield, ?Await]

[no LineTerminator here]

[?Yield, ?Await]

[no LineTerminator here]

[Yield, Await]

continue

;

continue

[no LineTerminator here]

[?Yield, ?Await]

;

[Yield, Await]

break

;

break

[no LineTerminator here]

[?Yield, ?Await]

;

[Yield, Await]

return

;

return

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

[Yield, Await]

throw

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

[In, Yield, Await]

[?Yield, ?Await]

[no LineTerminator here]

[?In]

[In, Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

这些受限生成式的实际效果如下：

当遇到一个被解析器它当作一个后缀运算符的 ++ 或 -- token，并且至少有一个 LineTerminator 出现在 ++ 或 -- token 和它之前的 token 之间时，那么在 ++ 或 -- token 前面会自动插入一个分号。
当遇到一个 continue, break, return, throw, 或 yield token，并且在下一个 token 前面遇到一个 LineTerminator 时，那么在 continue, break, return, throw, 或 yield 后面自动插入一个分号。

The resulting practical advice to ES programmers is:

后缀运算符 ++ 或 -- 和它的操作数应该出现在同一行。
return 或 throw 语句中的表达式或在一个 yield 表达式中的 AssignmentExpression 应该和 return, throw, 或 yield token 在同一行。
在 break 或 continue 语句中的 LabelIdentifier 应该和break 或 continue token 在同一行。

11.9.2自动分号插入的例子

源代码

{ 1 2 } 3

即使符号自动分号插入的规则，但在 ES 文法中却不是一个有效的句子。相比于，源代码

{ 1
                2 } 3

虽然也不是一个有效的句子，但是它会被自动分号插入转换成以下的形式：

{ 1
                  ;2 ;} 3;

从而成为一个有效的句子。

源代码

for (a; b
                  )

不是一个有效的 ES 句子，也不会被自动分号插入所更改，因为，对于一个 for 语句的头部而言，分号是必须的。自动分号插入从来不会插入成 for 语句头部的两个分号之一。

源代码

return
                  a + b

会被自动分号插入转换成以下形式：

return;
                  a + b;

Note 1

表达式 a + b 不会被当做 return 语句的返回值，因为有一个 LineTerminator 分隔了它和 return token。

源代码

a = b
                  ++c

会被自动分号插入转换成以下形式：

a = b;
                  ++c;

Note 2

++ token 不会被当做一个应用于变量 b 的后缀运算符，因为 b 和 ++ 之间出现了一个 LineTerminator。

源代码

if (a > b)
                    else c = d

不是一个有效的 ES 句子，且不会被在 else token 前面的自动分号插入所改变，即使没有文法生成式适用这一位置，因为自动插入了分号后会会被解析成一个空语句。

源代码

a = b + c
                    (d + e).print()

它不会被自动分号插入改变，因为第二行开始位置的括号表达式会被解释成函数调用的参数列表：

a = b + c(d + e).print()

在赋值语句必须用左括号开头的情况下，程序员在前面语句的结束位置明确的提供一个分号是个好主意，而不是依赖于自动分号插入。

12ES 语言: 表达式

12.1标识符

Syntax

[Yield, Await]

[~Yield]

yield

[~Await]

await

[Yield, Await]

yield

await

[Yield, Await]

[~Yield]

yield

[~Await]

await

but not ReservedWord

Note

在文法中，yield 和 await 作为 BindingIdentifier 是被允许的，但是在下面的静态语义中是被禁止的，下面的例子中禁止自动分号插入

let
                      await 0;

12.1.1静态语义: 早期错误

这是一个句法错误如果 the code matched by this production is contained in 严格模式代码 and the 字符值 of Identifier is "arguments" or "eval".

yield

yield

yield

这是一个句法错误如果 the code matched by this production is contained in 严格模式代码.

await

await

await

这是一个句法错误如果 the 目标符 of 句法 is Module.

yield

这是一个句法错误如果 this production has a _[Yield] parameter.

await

这是一个句法错误如果 this production has an _[Await] parameter.

[Yield, Await]

[Yield, Await]

[Yield, Await]

这是一个句法错误如果 this production has a _[Yield] parameter and 字符值 of Identifier is "yield".
这是一个句法错误如果 this production has an _[Await] parameter and 字符值 of Identifier is "await".

but not ReservedWord

这是一个句法错误如果 this phrase is contained in 严格模式代码 and the 字符值 of IdentifierName is: "implements", "interface", "let", "package", "private", "protected", "public", "static", or "yield".
这是一个句法错误如果 the 目标符 of 句法 is Module and the 字符值 of IdentifierName is "await".
这是一个句法错误如果字符值 of IdentifierName is the same String 值 as the 字符值 of any ReservedWord except for yield or await.

Note

字符值 of IdentifierName normalizes any Unicode escape sequences in IdentifierName hence such escapes cannot be used to write an Identifier whose 码点 sequence is the same as a ReservedWord.

12.1.2静态语义: 绑定名

Return a new List containing the 字符值 of Identifier.

yield

Return a new List containing "yield".

await

Return a new List containing "await".

12.1.3静态语义: IsValidSimpleAssignmentTarget

If this IdentifierReference is contained in 严格模式代码 and 字符值 of Identifier is "eval" or "arguments", return false.
Return true.

yield

Return true.

await

Return true.

12.1.4静态语义: 字符值

yield

yield

yield

Return "yield".

await

await

await

Return "await".

but not ReservedWord

Return the 字符值 of IdentifierName.

12.1.5运行时语义: 绑定初始化

With parameters value and environment.

Note

undefined is passed for environment to indicate that a PutValue operation should be used to assign the initialization value. This is the case for var statements and formal parameter lists of some non-strict functions (See 9.2.13). In those cases a lexical binding is hoisted and preinitialized prior to 估值 of its 初始化器.

Let name be 字符值 of Identifier.
Return ? InitializeBoundName(name, value, environment).

yield

Return ? InitializeBoundName("yield", value, environment).

await

Return ? InitializeBoundName("await", value, environment).

12.1.5.1运行时语义: InitializeBoundName ( `name`, `value`, `environment` )

Assert: Type(name) is String.
If environment is not undefined, then
1. Let env be the EnvironmentRecord component of environment.
2. Perform env.InitializeBinding(name, value).
3. Return NormalCompletion(undefined).
Else,
1. Let lhs be ResolveBinding(name).
2. Return ? PutValue(lhs, value).

12.1.6运行时语义: 估值

Return ? ResolveBinding(字符值 of Identifier).

yield

Return ? ResolveBinding("yield").

await

Return ? ResolveBinding("await").

Note 1

The result of evaluating an IdentifierReference is always a value of type Reference.

Note 2

In non-strict code, the keyword yield may be used as an identifier. Evaluating the IdentifierReference resolves the binding of yield as if it was an Identifier. 早期错误 restriction ensures that such an 估值 only can occur for non-strict code.

12.2主值表达式

Syntax

[Yield, Await]

this

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, ~Tagged]

[?Yield, ?Await]

[Yield, Await]

(

[+In, ?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

)

(

)

(

...

[?Yield, ?Await]

)

(

...

[?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

...

[?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

...

[?Yield, ?Await]

)

补充语法

When processing an instance of the production
PrimaryExpression[Yield, Await]:CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
the interpretation of CoverParenthesizedExpressionAndArrowParameterList is refined using the following grammar:

[Yield, Await]

(

[+In, ?Yield, ?Await]

)

12.2.1语义

12.2.1.1静态语义: CoveredParenthesizedExpression

(

)

Return the ParenthesizedExpression that is covered by CoverParenthesizedExpressionAndArrowParameterList.

12.2.1.2静态语义: HasName

Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
If 是函数定义 of expr is false, return false.
Return HasName of expr.

12.2.1.3静态语义: 是函数定义

this

Return false.

Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
Return 是函数定义 of expr.

12.2.1.4静态语义: 是标识符引用

Return true.

this

Return false.

12.2.1.5静态语义: IsValidSimpleAssignmentTarget

this

Return false.

Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
Return IsValidSimpleAssignmentTarget of expr.

12.2.2`this` 关键字

12.2.2.1运行时语义: 估值

this

Return ? ResolveThisBinding( ).

12.2.3标识符引用

See 12.1 for IdentifierReference.

12.2.4字面量

Syntax

12.2.4.1运行时语义: 估值

NullLiteral

Return null.

BooleanLiteral

If BooleanLiteral is the token false, return false.
If BooleanLiteral is the token true, return true.

NumericLiteral

Return the number whose value is MV of NumericLiteral as defined in 11.8.3.

Return the 字符值 of StringLiteral as defined in 11.8.4.1.

12.2.5数组初始化器

Note

数组字面量是用来描述一个数组对象初始化的表达式，它是一个由零个或者多个表达式组成的并被方括号括起来的列表，其中每一个表达式表示一个数组元素。其元素不需要是字面量，每次数组初始化器估值时时它们都会被再估值一次。

Array elements may be elided at the beginning, middle or end of the element list. Whenever a comma in the element list is not preceded by an AssignmentExpression (i.e., a comma at the beginning or after another comma), the missing array element contributes to the length of the Array and increases the index of subsequent elements. Elided array elements are not defined. If an element is elided at the end of an array, that element does not contribute to the length of the Array.数组元素可能在元素列表的开始、结束，或者中间位置被省略。每当元素列表中的一个逗号不在 AssignmentExpression 之前（如，一个逗号在另一个逗号之前）时，缺失的数组元素会对数组长度有贡献，并且增加后续元素的索引值。被省略的数组元素是没有定义的。如果一个元素在数组末尾被省略，那么该元素不会对数组的长度有贡献。

Syntax

[Yield, Await]

[

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

]

[Yield, Await]

opt

[+In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?Yield, ?Await]

opt

[+In, ?Yield, ?Await]

[?Yield, ?Await]

opt

[?Yield, ?Await]

[Yield, Await]

...

[+In, ?Yield, ?Await]

12.2.5.1静态语义: ElisionWidth

Return the 数字值 1.

Let preceding be the ElisionWidth of Elision.
Return preceding+1.

12.2.5.2运行时语义: ArrayAccumulation

With parameters array and nextIndex.

opt

Let padding be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Let initResult be the result of evaluating AssignmentExpression.
Let initValue be ? GetValue(initResult).
Let created be CreateDataProperty(array, ToString(ToUint32(nextIndex+padding)), initValue).
Assert: created is true.
Return nextIndex+padding+1.

opt

SpreadElement

Let padding be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Return the result of performing ArrayAccumulation for SpreadElement with arguments array and nextIndex+padding.

opt

Let postIndex be the result of performing ArrayAccumulation for ElementList with arguments array and nextIndex.
ReturnIfAbrupt(postIndex).
Let padding be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Let initResult be the result of evaluating AssignmentExpression.
Let initValue be ? GetValue(initResult).
Let created be CreateDataProperty(array, ToString(ToUint32(postIndex+padding)), initValue).
Assert: created is true.
Return postIndex+padding+1.

opt

SpreadElement

Let postIndex be the result of performing ArrayAccumulation for ElementList with arguments array and nextIndex.
ReturnIfAbrupt(postIndex).
Let padding be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Return the result of performing ArrayAccumulation for SpreadElement with arguments array and postIndex+padding.

SpreadElement

...

Let spreadRef be the result of evaluating AssignmentExpression.
Let spreadObj be ? GetValue(spreadRef).
Let iteratorRecord be ? GetIterator(spreadObj).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return nextIndex.
3. Let nextValue be ? IteratorValue(next).
4. Let status be CreateDataProperty(array, ToString(ToUint32(nextIndex)), nextValue).
5. Assert: status is true.
6. Let nextIndex be nextIndex + 1.

Note

CreateDataProperty is used to ensure that 自身属性 are defined for the array even if the 标准内置 Array 原型对象 has been modified in a manner that would preclude the creation of new 自身属性 using [[Set]].

12.2.5.3运行时语义: 估值

[

opt

]

Let array be ! ArrayCreate(0).
Let pad be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Perform Set(array, "length", ToUint32(pad), false).
NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
Return array.

[

]

Let array be ! ArrayCreate(0).
Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
ReturnIfAbrupt(len).
Perform Set(array, "length", ToUint32(len), false).
NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
Return array.

[

opt

]

Let array be ! ArrayCreate(0).
Let len be the result of performing ArrayAccumulation for ElementList with arguments array and 0.
ReturnIfAbrupt(len).
Let padding be the ElisionWidth of Elision; if Elision is not present, use the 数字值 zero.
Perform Set(array, "length", ToUint32(padding+len), false).
NOTE: The above Set cannot fail because of the nature of the object returned by ArrayCreate.
Return array.

12.2.6对象初始化器

Note 1

对象初始化器是一个以类似字面量的形式描述对象初始化过程的表达式。它是用大括号括起来的由零或者多对属性键 / 关联值组成的列表，值不需要是字面量，每次对象初始化器被估值时他们会被再估值一次。

Syntax

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[

[+In, ?Yield, ?Await]

]

CoverInitializedName

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

Note 2

MethodDefinition is defined in 14.3.

Note 3

In certain contexts, ObjectLiteral is used as a cover grammar for a more restricted secondary grammar. The CoverInitializedName production is necessary to fully cover these secondary grammars. However, use of this production results in an early Syntax Error in normal contexts where an actual ObjectLiteral is expected.

12.2.6.1静态语义: 早期错误

这是一个句法错误如果 HasDirectSuper of MethodDefinition is true.

In addition to describing an actual 对象初始化器 the ObjectLiteral productions are also used as a cover grammar for ObjectAssignmentPattern and may be recognized as part of a CoverParenthesizedExpressionAndArrowParameterList. When ObjectLiteral appears in a context where ObjectAssignmentPattern is required the following 早期错误 rules are not applied. In addition, they are not applied when initially parsing a CoverParenthesizedExpressionAndArrowParameterList or CoverCallExpressionAndAsyncArrowHead.

CoverInitializedName

Always 抛出一个 Syntax Error if code matches this production.

Note

This production exists so that ObjectLiteral can serve as a cover grammar for ObjectAssignmentPattern. It cannot occur in an actual 对象初始化器.

12.2.6.2静态语义: 可计算的属性包含

With parameter symbol.

Return false.

Return the result of ComputedPropertyName Contains symbol.

12.2.6.3静态语义: Contains

With parameter symbol.

If symbol is MethodDefinition, return true.
Return the result of 可计算的属性包含 for MethodDefinition with argument symbol.

Note

静态语义规则 that depend upon substructure generally do not look into 函数定义.

If symbol is a ReservedWord, return false.
If symbol is an Identifier and 字符值 of symbol is the same value as the 字符值 of IdentifierName, return true.
Return false.

12.2.6.4静态语义: IsComputedPropertyKey

Return false.

Return true.

12.2.6.5静态语义: 属性名

Return 字符值 of IdentifierReference.

...

Return empty.

Return 属性名 of PropertyName.

Return 字符值 of IdentifierName.

Return the String 值 whose 代码单元 are the SV of the StringLiteral.

NumericLiteral

Let nbr be the result of forming the value of the NumericLiteral.
Return ! ToString(nbr).

[

]

Return empty.

12.2.6.6静态语义: 属性名列表

If 属性名 of PropertyDefinition is empty, return a new empty List.
Return a new List containing 属性名 of PropertyDefinition.

Let list be 属性名列表 of PropertyDefinitionList.
If 属性名 of PropertyDefinition is empty, return list.
Append 属性名 of PropertyDefinition to the end of list.
Return list.

12.2.6.7运行时语义: 估值

{

}

Return ObjectCreate(%ObjectPrototype%).

{

}

{

}

Let obj be ObjectCreate(%ObjectPrototype%).
Perform ? 属性定义估值 of PropertyDefinitionList with arguments obj and true.
Return obj.

Return 字符值 of IdentifierName.

Return the String 值 whose 代码单元 are the SV of the StringLiteral.

NumericLiteral

Let nbr be the result of forming the value of the NumericLiteral.
Return ! ToString(nbr).

[

]

Let exprValue be the result of evaluating AssignmentExpression.
Let 属性名 be ? GetValue(exprValue).
Return ? ToPropertyKey(属性名).

12.2.6.8运行时语义: 属性定义估值

With parameters object and enumerable.

Perform ? 属性定义估值 of PropertyDefinitionList with arguments object and enumerable.
Return the result of performing 属性定义估值 of PropertyDefinition with arguments object and enumerable.

...

Let exprValue be the result of evaluating AssignmentExpression.
Let fromValue be ? GetValue(exprValue).
Let excludedNames be a new empty List.
Return ? CopyDataProperties(object, fromValue, excludedNames).

Let 属性名 be 字符值 of IdentifierReference.
Let exprValue be the result of evaluating IdentifierReference.
Let propValue be ? GetValue(exprValue).
Assert: enumerable is true.
Return CreateDataPropertyOrThrow(object, 属性名, propValue).

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
Let exprValueRef be the result of evaluating AssignmentExpression.
Let propValue be ? GetValue(exprValueRef).
If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
1. Let hasNameProperty be ? HasOwnProperty(propValue, "name").
2. If hasNameProperty is false, perform SetFunctionName(propValue, propKey).
Assert: enumerable is true.
Return CreateDataPropertyOrThrow(object, propKey, propValue).

Note

An alternative 语义 for this production is given in B.3.1.

12.2.7函数定义表达式

See 14.1 for PrimaryExpression:FunctionExpression .

See 14.4 for PrimaryExpression:GeneratorExpression .

See 14.6 for PrimaryExpression:ClassExpression .

See 14.7 for PrimaryExpression:AsyncFunctionExpression .

See 14.5 for PrimaryExpression:AsyncGeneratorExpression .

12.2.8正则表达式字面量

Syntax

See 11.8.5.

12.2.8.1静态语义: 早期错误

这是一个句法错误如果 BodyText of RegularExpressionLiteral cannot be recognized using the 目标符 Pattern of the ES RegExp grammar specified in 21.2.1.
这是一个句法错误如果 FlagText of RegularExpressionLiteral contains any code points other than "g", "i", "m", "u", or "y", or if it contains the same 码点 more than once.

12.2.8.2运行时语义: 估值

Let pattern be the String 值 consisting of the UTF16Encoding of each 码点 of BodyText of RegularExpressionLiteral.
Let flags be the String 值 consisting of the UTF16Encoding of each 码点 of FlagText of RegularExpressionLiteral.
Return RegExpCreate(pattern, flags).

12.2.9模板字面量

Syntax

[Yield, Await, Tagged]

[?Yield, ?Await, ?Tagged]

[Yield, Await, Tagged]

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Tagged]

[Yield, Await, Tagged]

[?Yield, ?Await, ?Tagged]

[Yield, Await, Tagged]

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Tagged]

[+In, ?Yield, ?Await]

12.2.9.1静态语义: 早期错误

[Yield, Await, Tagged]

这是一个句法错误如果 the number of elements in the result of 模板字符串 of TemplateLiteral with argument false is greater than 2³²-1.
这是一个句法错误如果 the _[Tagged] parameter was not set and NoSubstitutionTemplate Contains NotEscapeSequence.

[Yield, Await, Tagged]

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Tagged]

这是一个句法错误如果 the _[Tagged] parameter was not set and TemplateHead Contains NotEscapeSequence.

[Yield, Await, Tagged]

这是一个句法错误如果 the _[Tagged] parameter was not set and TemplateTail Contains NotEscapeSequence.

[Yield, Await, Tagged]

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Tagged]

[+In, ?Yield, ?Await]

这是一个句法错误如果 the _[Tagged] parameter was not set and TemplateMiddle Contains NotEscapeSequence.

12.2.9.2静态语义: 模板字符串

With parameter raw.

If raw is false, then
1. Let string be the TV of NoSubstitutionTemplate.
Else,
1. Let string be the TRV of NoSubstitutionTemplate.
Return a List containing the single element, string.

If raw is false, then
1. Let head be the TV of TemplateHead.
Else,
1. Let head be the TRV of TemplateHead.
Let tail be 模板字符串 of TemplateSpans with argument raw.
Return a List containing head followed by the elements, in order, of tail.

If raw is false, then
1. Let tail be the TV of TemplateTail.
Else,
1. Let tail be the TRV of TemplateTail.
Return a List containing the single element, tail.

Let middle be 模板字符串 of TemplateMiddleList with argument raw.
If raw is false, then
1. Let tail be the TV of TemplateTail.
Else,
1. Let tail be the TRV of TemplateTail.
Return a List containing the elements, in order, of middle followed by tail.

If raw is false, then
1. Let string be the TV of TemplateMiddle.
Else,
1. Let string be the TRV of TemplateMiddle.
Return a List containing the single element, string.

Let front be 模板字符串 of TemplateMiddleList with argument raw.
If raw is false, then
1. Let last be the TV of TemplateMiddle.
Else,
1. Let last be the TRV of TemplateMiddle.
Append last as the last element of the List front.
Return front.

12.2.9.3运行时语义: 参数列表估值

Let templateLiteral be this TemplateLiteral.
Let siteObj be GetTemplateObject(templateLiteral).
Return a List containing the one element which is siteObj.

Let templateLiteral be this TemplateLiteral.
Let siteObj be GetTemplateObject(templateLiteral).
Let firstSubRef be the result of evaluating Expression.
Let firstSub be ? GetValue(firstSubRef).
Let restSub be SubstitutionEvaluation of TemplateSpans.
ReturnIfAbrupt(restSub).
Assert: restSub is a List.
Return a List whose first element is siteObj, whose second elements is firstSub, and whose subsequent elements are the elements of restSub, in order. restSub may contain no elements.

12.2.9.4运行时语义: GetTemplateObject ( `templateLiteral` )

The 抽象操作 GetTemplateObject is called with a 解析节点, templateLiteral, as an argument. It 执行如下:

Let rawStrings be 模板字符串 of templateLiteral with argument true.
Let realm be the current Realm Record.
Let templateRegistry be realm.[[TemplateMap]].
For each element e of templateRegistry, do
1. If e.[[Site]] is the same 解析节点 as templateLiteral, then
  1. Return e.[[Array]].
Let cookedStrings be 模板字符串 of templateLiteral with argument false.
Let count be the number of elements in the List cookedStrings.
Assert: count ≤ 2³²-1.
Let template be ! ArrayCreate(count).
Let rawObj be ! ArrayCreate(count).
Let index be 0.
Repeat, while index < count
1. Let prop be ! ToString(index).
2. Let cookedValue be the String 值 cookedStrings[index].
3. Call template.[[DefineOwnProperty]](prop, PropertyDescriptor{[[Value]]: cookedValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}).
4. Let rawValue be the String 值 rawStrings[index].
5. Call rawObj.[[DefineOwnProperty]](prop, PropertyDescriptor{[[Value]]: rawValue, [[Writable]]: false, [[Enumerable]]: true, [[Configurable]]: false}).
6. Let index be index+1.
Perform SetIntegrityLevel(rawObj, "frozen").
Call template.[[DefineOwnProperty]]("raw", PropertyDescriptor{[[Value]]: rawObj, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetIntegrityLevel(template, "frozen").
Append the Record{[[Site]]: templateLiteral, [[Array]]: template} to templateRegistry.
Return template.

Note 1

The creation of a template object cannot result in an abrupt completion.

Note 2

Each TemplateLiteral in the program code of a realm is associated with a unique template object that is used in the 估值 of 标签模板 (12.2.9.6). The template objects are frozen and the same template object is used each time a specific tagged Template is evaluated. Whether template objects are created lazily upon first 估值 of the TemplateLiteral or eagerly prior to first 估值 is an 实现 choice that is not observable to ES 代码.

Note 3

Future editions of this specification may define additional non-enumerable properties of template objects.

12.2.9.5运行时语义: SubstitutionEvaluation

Return a new empty List.

Return the result of SubstitutionEvaluation of TemplateMiddleList.

Let subRef be the result of evaluating Expression.
Let sub be ? GetValue(subRef).
Return a List containing only sub.

Let preceding be the result of SubstitutionEvaluation of TemplateMiddleList.
ReturnIfAbrupt(preceding).
Let nextRef be the result of evaluating Expression.
Let next be ? GetValue(nextRef).
Append next as the last element of the List preceding.
Return preceding.

12.2.9.6运行时语义: 估值

Return the String 值 whose 代码单元 are the elements of the TV of NoSubstitutionTemplate as defined in 11.8.6.

Let head be the TV of TemplateHead as defined in 11.8.6.
Let sub be the result of evaluating Expression.
ReturnIfAbrupt(sub).
Let middle be ? ToString(sub).
Let tail be the result of evaluating TemplateSpans.
ReturnIfAbrupt(tail).
Return the string-concatenation of head, middle, and tail.

Note 1

The string conversion 语义 applied to the Expression value are like String.prototype.concat rather than the + 运算符.

Let tail be the TV of TemplateTail as defined in 11.8.6.
Return the String 值 consisting of the 代码单元 of tail.

Let head be the result of evaluating TemplateMiddleList.
ReturnIfAbrupt(head).
Let tail be the TV of TemplateTail as defined in 11.8.6.
Return the string-concatenation of head and tail.

Let head be the TV of TemplateMiddle as defined in 11.8.6.
Let sub be the result of evaluating Expression.
ReturnIfAbrupt(sub).
Let middle be ? ToString(sub).
Return the sequence of 代码单元 consisting of the 代码单元 of head followed by the elements of middle.

Note 2

The string conversion 语义 applied to the Expression value are like String.prototype.concat rather than the + 运算符.

Let rest be the result of evaluating TemplateMiddleList.
ReturnIfAbrupt(rest).
Let middle be the TV of TemplateMiddle as defined in 11.8.6.
Let sub be the result of evaluating Expression.
ReturnIfAbrupt(sub).
Let last be ? ToString(sub).
Return the sequence of 代码单元 consisting of the elements of rest followed by the 代码单元 of middle followed by the elements of last.

Note 3

The string conversion 语义 applied to the Expression value are like String.prototype.concat rather than the + 运算符.

12.2.10分组运算符

12.2.10.1静态语义: 早期错误

这是一个句法错误如果 CoverParenthesizedExpressionAndArrowParameterList is not covering a ParenthesizedExpression.
All 早期错误 rules for ParenthesizedExpression and its derived productions also apply to CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.

12.2.10.2静态语义: 是函数定义

(

)

Return 是函数定义 of Expression.

12.2.10.3静态语义: IsValidSimpleAssignmentTarget

(

)

Return IsValidSimpleAssignmentTarget of Expression.

12.2.10.4运行时语义: 估值

Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
Return the result of evaluating expr.

(

)

Return the result of evaluating Expression. This may be of type Reference.

Note

This 算法 does not apply GetValue to the result of evaluating Expression. The principal motivation for this is so that operators 例如 delete and typeof may be applied to parenthesized expressions.

12.3左表达式

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[

[+In, ?Yield, ?Await]

]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, +Tagged]

[?Yield, ?Await]

new

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

super

[

[+In, ?Yield, ?Await]

]

super

MetaProperty

NewTarget

new

target

[Yield, Await]

[?Yield, ?Await]

new

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[

[+In, ?Yield, ?Await]

]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, +Tagged]

SuperCall

[Yield, Await]

super

[?Yield, ?Await]

[Yield, Await]

(

)

(

[?Yield, ?Await]

)

(

[?Yield, ?Await]

)

[Yield, Await]

[+In, ?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

Supplemental Syntax

When processing an instance of the production CallExpression:CoverCallExpressionAndAsyncArrowHead the interpretation of CoverCallExpressionAndAsyncArrowHead is refined using the following grammar:

CallMemberExpression

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

12.3.1静态语义

12.3.1.1静态语义: CoveredCallExpression

Return the CallMemberExpression that is covered by CoverCallExpressionAndAsyncArrowHead.

12.3.1.2静态语义: Contains

With parameter symbol.

If MemberExpression Contains symbol is true, return true.
If symbol is a ReservedWord, return false.
If symbol is an Identifier and 字符值 of symbol is the same value as the 字符值 of IdentifierName, return true.
Return false.

SuperProperty

super

If symbol is the ReservedWord super, return true.
If symbol is a ReservedWord, return false.
If symbol is an Identifier and 字符值 of symbol is the same value as the 字符值 of IdentifierName, return true.
Return false.

If CallExpression Contains symbol is true, return true.
If symbol is a ReservedWord, return false.
If symbol is an Identifier and 字符值 of symbol is the same value as the 字符值 of IdentifierName, return true.
Return false.

12.3.1.3静态语义: 是函数定义

[

]

new

new

Return false.

12.3.1.4静态语义: 是解构

If PrimaryExpression is either an ObjectLiteral or an ArrayLiteral, return true.
Return false.

[

]

new

new

Return false.

12.3.1.5静态语义: 是标识符引用

[

]

new

new

Return false.

12.3.1.6静态语义: IsValidSimpleAssignmentTarget

[

]

[

]

Return true.

new

new

new

target

Return false.

12.3.2属性访问器

Note

属性是通过名字访问的，使用点符号表示法：

.

.

或者使用方括号表示法：

[

]

[

]

点符号表示法可以用以下句法转换来解释：

.

它的行为等同于

[ <identifier-name-string> ]

类似地

.

它的行为等同于

[ <identifier-name-string> ]

where <identifier-name-string> is the result of evaluating 字符值 of IdentifierName.

12.3.2.1运行时语义: 估值

[

]

Let baseReference be the result of evaluating MemberExpression.
Let baseValue be ? GetValue(baseReference).
Let propertyNameReference be the result of evaluating Expression.
Let propertyNameValue be ? GetValue(propertyNameReference).
Let bv be ? RequireObjectCoercible(baseValue).
Let propertyKey be ? ToPropertyKey(propertyNameValue).
If the code matched by this MemberExpression is 严格模式代码, let strict be true, else let strict be false.
Return a value of type Reference whose base value component is bv, whose referenced name component is propertyKey, and whose strict reference flag is strict.

Let baseReference be the result of evaluating MemberExpression.
Let baseValue be ? GetValue(baseReference).
Let bv be ? RequireObjectCoercible(baseValue).
Let propertyNameString be 字符值 of IdentifierName.
If the code matched by this MemberExpression is 严格模式代码, let strict be true, else let strict be false.
Return a value of type Reference whose base value component is bv, whose referenced name component is propertyNameString, and whose strict reference flag is strict.

[

]

Is evaluated in exactly the same manner as MemberExpression:MemberExpression[Expression] except that the contained CallExpression is evaluated in step 1.

Is evaluated in exactly the same manner as MemberExpression:MemberExpression.IdentifierName except that the contained CallExpression is evaluated in step 1.

12.3.3`new` 操作符

12.3.3.1运行时语义: 估值

new

Return ? EvaluateNew(NewExpression, empty).

new

Return ? EvaluateNew(MemberExpression, Arguments).

12.3.3.1.1运行时语义: EvaluateNew ( `constructExpr`, `arguments` )

The 抽象操作 EvaluateNew with arguments constructExpr, and arguments 执行如下:

Assert: constructExpr is either a NewExpression or a MemberExpression.
Assert: arguments is either empty or an Arguments.
Let ref be the result of evaluating constructExpr.
Let 构造器 be ? GetValue(ref).
If arguments is empty, let argList be a new empty List.
Else,
1. Let argList be 参数列表估值 of arguments.
2. ReturnIfAbrupt(argList).
If IsConstructor(构造器) is false, 抛出一个 TypeError 异常.
Return ? Construct(构造器, argList).

12.3.4函数调用

12.3.4.1运行时语义: 估值

Let expr be CoveredCallExpression of CoverCallExpressionAndAsyncArrowHead.
Let memberExpr be the MemberExpression of expr.
Let arguments be the Arguments of expr.
Let ref be the result of evaluating memberExpr.
Let func be ? GetValue(ref).
If Type(ref) is Reference and IsPropertyReference(ref) is false and GetReferencedName(ref) is "eval", then
1. If SameValue(func, %eval%) is true, then
  1. Let argList be ? 参数列表估值 of arguments.
  2. If argList has no elements, return undefined.
  3. Let evalText be the first element of argList.
  4. If the source code matching this CallExpression is 严格模式代码, let strictCaller be true. Otherwise let strictCaller be false.
  5. Let evalRealm be the current Realm Record.
  6. Perform ? HostEnsureCanCompileStrings(evalRealm, evalRealm).
  7. Return ? PerformEval(evalText, evalRealm, strictCaller, true).
Let thisCall be this CallExpression.
Let tailCall be IsInTailPosition(thisCall).
Return ? EvaluateCall(func, ref, arguments, tailCall).

A CallExpression 估值 that executes step 6.a.vii is a direct eval.

Let ref be the result of evaluating CallExpression.
Let func be ? GetValue(ref).
Let thisCall be this CallExpression.
Let tailCall be IsInTailPosition(thisCall).
Return ? EvaluateCall(func, ref, Arguments, tailCall).

12.3.4.2运行时语义: EvaluateCall(`func`, `ref`, `arguments`, `tailPosition` )

The 抽象操作 EvaluateCall takes as arguments a value func, a value ref, a 解析节点 arguments, and a Boolean argument tailPosition. It 执行如下:

If Type(ref) is Reference, then
1. If IsPropertyReference(ref) is true, then
  1. Let thisValue be GetThisValue(ref).
2. Else the base of ref is an 环境记录,
  1. Let refEnv be GetBase(ref).
  2. Let thisValue be refEnv.WithBaseObject().
Else Type(ref) is not Reference,
1. Let thisValue be undefined.
Let argList be 参数列表估值 of arguments.
ReturnIfAbrupt(argList).
If Type(func) is not Object, 抛出一个 TypeError 异常.
If IsCallable(func) is false, 抛出一个 TypeError 异常.
If tailPosition is true, perform PrepareForTailCall().
Let result be Call(func, thisValue, argList).
Assert: If tailPosition is true, the above call will not return here, but instead 估值 will continue as if the following return has already occurred.
Assert: If result is not an abrupt completion, then Type(result) is an ES language type.
Return result.

12.3.5`super` 关键字

12.3.5.1运行时语义: 估值

SuperProperty

super

[

]

Let propertyNameReference be the result of evaluating Expression.
Let propertyNameValue be ? GetValue(propertyNameReference).
Let propertyKey be ? ToPropertyKey(propertyNameValue).
If the code matched by this SuperProperty is 严格模式代码, let strict be true, else let strict be false.
Return ? MakeSuperPropertyReference(propertyKey, strict).

SuperProperty

super

Let propertyKey be 字符值 of IdentifierName.
If the code matched by this SuperProperty is 严格模式代码, let strict be true, else let strict be false.
Return ? MakeSuperPropertyReference(propertyKey, strict).

SuperCall

super

Let newTarget be GetNewTarget().
Assert: Type(newTarget) is Object.
Let func be ? GetSuperConstructor().
Let argList be 参数列表估值 of Arguments.
ReturnIfAbrupt(argList).
Let result be ? Construct(func, argList, newTarget).
Let thisER be GetThisEnvironment( ).
Return ? thisER.BindThisValue(result).

12.3.5.2运行时语义: GetSuperConstructor ( )

The 抽象操作 GetSuperConstructor 执行如下:

Let envRec be GetThisEnvironment( ).
Assert: envRec is a 函数环境记录.
Let activeFunction be envRec.[[FunctionObject]].
Assert: activeFunction is an ES 函数对象.
Let superConstructor be ! activeFunction.[[GetPrototypeOf]]().
If IsConstructor(superConstructor) is false, 抛出一个 TypeError 异常.
Return superConstructor.

12.3.5.3运行时语义: MakeSuperPropertyReference ( `propertyKey`, `strict` )

The 抽象操作 MakeSuperPropertyReference with arguments propertyKey and strict 执行如下:

Let env be GetThisEnvironment( ).
Assert: env.HasSuperBinding() is true.
Let actualThis be ? env.GetThisBinding().
Let baseValue be ? env.GetSuperBase().
Let bv be ? RequireObjectCoercible(baseValue).
Return a value of type Reference that is a Super 引用 whose base value component is bv, whose referenced name component is propertyKey, whose thisValue component is actualThis, and whose strict reference flag is strict.

12.3.6参数列表

Note

The 估值 of an argument list produces a List of values.

12.3.6.1运行时语义: 参数列表估值

(

)

Return a new empty List.

Let ref be the result of evaluating AssignmentExpression.
Let arg be ? GetValue(ref).
Return a List whose sole item is arg.

...

Let list be a new empty List.
Let spreadRef be the result of evaluating AssignmentExpression.
Let spreadObj be ? GetValue(spreadRef).
Let iteratorRecord be ? GetIterator(spreadObj).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return list.
3. Let nextArg be ? IteratorValue(next).
4. Append nextArg as the last element of list.

Let precedingArgs be 参数列表估值 of ArgumentList.
ReturnIfAbrupt(precedingArgs).
Let ref be the result of evaluating AssignmentExpression.
Let arg be ? GetValue(ref).
Append arg to the end of precedingArgs.
Return precedingArgs.

...

Let precedingArgs be 参数列表估值 of ArgumentList.
ReturnIfAbrupt(precedingArgs).
Let spreadRef be the result of evaluating AssignmentExpression.
Let iteratorRecord be ? GetIterator(? GetValue(spreadRef)).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return precedingArgs.
3. Let nextArg be ? IteratorValue(next).
4. Append nextArg as the last element of precedingArgs.

12.3.7标签模板

Note

A tagged template is a function call where the arguments of the call are derived from a TemplateLiteral (12.2.9). The actual arguments include a template object (12.2.9.4) and the values produced by evaluating the expressions embedded within the TemplateLiteral.

12.3.7.1运行时语义: 估值

Let tagRef be the result of evaluating MemberExpression.
Let tagFunc be ? GetValue(tagRef).
Let thisCall be this MemberExpression.
Let tailCall be IsInTailPosition(thisCall).
Return ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall).

Let tagRef be the result of evaluating CallExpression.
Let tagFunc be ? GetValue(tagRef).
Let thisCall be this CallExpression.
Let tailCall be IsInTailPosition(thisCall).
Return ? EvaluateCall(tagFunc, tagRef, TemplateLiteral, tailCall).

12.3.8元属性

12.3.8.1运行时语义: 估值

NewTarget

new

target

Return GetNewTarget().

12.4更新表达式

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[no LineTerminator here]

[?Yield, ?Await]

[no LineTerminator here]

[?Yield, ?Await]

[?Yield, ?Await]

12.4.1静态语义: 早期错误

It is an early Reference Error if IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.

It is an early Reference Error if IsValidSimpleAssignmentTarget of UnaryExpression is false.

12.4.2静态语义: 是函数定义

Return false.

12.4.3静态语义: IsValidSimpleAssignmentTarget

Return false.

12.4.4后缀递增运算符

12.4.4.1运行时语义: 估值

Let lhs be the result of evaluating LeftHandSideExpression.
Let oldValue be ? ToNumber(? GetValue(lhs)).
Let newValue be the result of adding the value 1 to oldValue, using the same rules as for the + 运算符 (see 12.8.5).
Perform ? PutValue(lhs, newValue).
Return oldValue.

12.4.5后缀递减运算符

12.4.5.1运行时语义: 估值

Let lhs be the result of evaluating LeftHandSideExpression.
Let oldValue be ? ToNumber(? GetValue(lhs)).
Let newValue be the result of subtracting the value 1 from oldValue, using the same rules as for the - 运算符 (see 12.8.5).
Perform ? PutValue(lhs, newValue).
Return oldValue.

12.4.6前缀递增运算符

12.4.6.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Let oldValue be ? ToNumber(? GetValue(expr)).
Let newValue be the result of adding the value 1 to oldValue, using the same rules as for the + 运算符 (see 12.8.5).
Perform ? PutValue(expr, newValue).
Return newValue.

12.4.7前缀递减运算符

12.4.7.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Let oldValue be ? ToNumber(? GetValue(expr)).
Let newValue be the result of subtracting the value 1 from oldValue, using the same rules as for the - 运算符 (see 12.8.5).
Perform ? PutValue(expr, newValue).
Return newValue.

12.5一元运算符

Syntax

[Yield, Await]

[?Yield, ?Await]

delete

[?Yield, ?Await]

void

[?Yield, ?Await]

typeof

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+Await]

AwaitExpression

[?Yield]

12.5.1静态语义: 是函数定义

delete

void

typeof

Return false.

12.5.2静态语义: IsValidSimpleAssignmentTarget

delete

void

typeof

Return false.

12.5.3`delete` 操作符

12.5.3.1静态语义: 早期错误

delete

这是一个句法错误如果 the UnaryExpression is contained in 严格模式代码 and the derived UnaryExpression is PrimaryExpression:IdentifierReference .
这是一个句法错误如果 the derived UnaryExpression is
PrimaryExpression:CoverParenthesizedExpressionAndArrowParameterList
and CoverParenthesizedExpressionAndArrowParameterList ultimately derives a phrase that, if used in place of UnaryExpression, would produce a Syntax Error according to these rules. This rule is recursively applied.

Note

The last rule means that expressions 例如 delete (((foo))) produce 早期错误 because of recursive application of the first rule.

12.5.3.2运行时语义: 估值

delete

Let ref be the result of evaluating UnaryExpression.
ReturnIfAbrupt(ref).
If Type(ref) is not Reference, return true.
If IsUnresolvableReference(ref) is true, then
1. Assert: IsStrictReference(ref) is false.
2. Return true.
If IsPropertyReference(ref) is true, then
1. If IsSuperReference(ref) is true, 抛出一个 ReferenceError 异常.
2. Let baseObj be ! ToObject(GetBase(ref)).
3. Let deleteStatus be ? baseObj.[[Delete]](GetReferencedName(ref)).
4. If deleteStatus is false and IsStrictReference(ref) is true, 抛出一个 TypeError 异常.
5. Return deleteStatus.
Else ref is a Reference to an 环境记录 binding,
1. Let bindings be GetBase(ref).
2. Return ? bindings.DeleteBinding(GetReferencedName(ref)).

Note

When a delete 运算符 occurs within 严格模式代码, a SyntaxError 异常 is thrown if its UnaryExpression is a direct reference to a variable, function argument, or function name. In addition, if a delete 运算符 occurs within 严格模式代码 and the property to be deleted has the 特性 { [[Configurable]]: false }, a TypeError 异常 is thrown.

12.5.4`void` 操作符

12.5.4.1运行时语义: 估值

void

Let expr be the result of evaluating UnaryExpression.
Perform ? GetValue(expr).
Return undefined.

Note

GetValue must be called even though its value is not used because it may have observable side-effects.

12.5.5`typeof 操作符`

12.5.5.1运行时语义: 估值

typeof

Let val be the result of evaluating UnaryExpression.
If Type(val) is Reference, then
1. If IsUnresolvableReference(val) is true, return "undefined".
Set val to ? GetValue(val).
Return a String according to Table 35.

Table 35: typeof 运算符 Results

Type of `val`	Result
Undefined	`"undefined"`
Null	`"object"`
Boolean	`"boolean"`
Number	`"number"`
String	`"string"`
Symbol	`"symbol"`
Object (ordinary and does not implement [[Call]])	`"object"`
Object (standard exotic and does not implement [[Call]])	`"object"`
Object (implements [[Call]])	`"function"`
Object (non-standard exotic and does not implement [[Call]])	实现-defined. Must not be `"undefined"`, `"boolean"`, `"function"`, `"number"`, `"symbol"`, or `"string"`.

Note

Implementations are discouraged from defining new typeof result values for non-standard 外来对象. If possible "object" should be used for such objects.

12.5.6一元 `+` 操作符

Note

The 一元 + 运算符 converts its operand to Number 类型.

12.5.6.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Return ? ToNumber(? GetValue(expr)).

12.5.7一元 `-` 操作符

Note

The 一元 - 运算符 converts its operand to Number 类型 and then negates it. Negating +0 produces -0, and negating -0 produces +0.

12.5.7.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Let oldValue be ? ToNumber(? GetValue(expr)).
If oldValue is NaN, return NaN.
Return the result of negating oldValue; that is, compute a Number with the same magnitude but opposite sign.

12.5.8按位非运算符 ( `~` )

12.5.8.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Let oldValue be ? ToInt32(? GetValue(expr)).
Return the result of applying bitwise complement to oldValue. The result is a signed 32-bit integer.

12.5.9逻辑非运算符 ( `!` )

12.5.9.1运行时语义: 估值

Let expr be the result of evaluating UnaryExpression.
Let oldValue be ToBoolean(? GetValue(expr)).
If oldValue is true, return false.
Return true.

12.6指数运算符

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

12.6.1静态语义: 是函数定义

Return false.

12.6.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.6.3运行时语义: 估值

Let left be the result of evaluating UpdateExpression.
Let leftValue be ? GetValue(left).
Let right be the result of evaluating ExponentiationExpression.
Let rightValue be ? GetValue(right).
Let base be ? ToNumber(leftValue).
Let exponent be ? ToNumber(rightValue).
Return the result of Applying the ** 运算符 with base and exponent as specified in 12.6.4.

12.6.4应用 `**` 运算符

Returns an 实现-dependent approximation of the result of raising base to the power exponent.

If exponent is NaN, the result is NaN.
If exponent is +0, the result is 1, even if base is NaN.
If exponent is -0, the result is 1, even if base is NaN.
If base is NaN and exponent is nonzero, the result is NaN.
If abs(base) > 1 and exponent is +∞, the result is +∞.
If abs(base) > 1 and exponent is -∞, the result is +0.
If abs(base) is 1 and exponent is +∞, the result is NaN.
If abs(base) is 1 and exponent is -∞, the result is NaN.
If abs(base) < 1 and exponent is +∞, the result is +0.
If abs(base) < 1 and exponent is -∞, the result is +∞.
If base is +∞ and exponent > 0, the result is +∞.
If base is +∞ and exponent < 0, the result is +0.
If base is -∞ and exponent > 0 and exponent is an odd integer, the result is -∞.
If base is -∞ and exponent > 0 and exponent is not an odd integer, the result is +∞.
If base is -∞ and exponent < 0 and exponent is an odd integer, the result is -0.
If base is -∞ and exponent < 0 and exponent is not an odd integer, the result is +0.
If base is +0 and exponent > 0, the result is +0.
If base is +0 and exponent < 0, the result is +∞.
If base is -0 and exponent > 0 and exponent is an odd integer, the result is -0.
If base is -0 and exponent > 0 and exponent is not an odd integer, the result is +0.
If base is -0 and exponent < 0 and exponent is an odd integer, the result is -∞.
If base is -0 and exponent < 0 and exponent is not an odd integer, the result is +∞.
If base < 0 and base is finite and exponent is finite and exponent is not an integer, the result is NaN.

Note

The result of base ** exponent when base is 1 or -1 and exponent is +Infinity or -Infinity differs from IEEE 754-2008. The first edition of ES specified a result of NaN for this operation, whereas later versions of IEEE 754-2008 specified 1. The historical ES behaviour is preserved for compatibility reasons.

12.7乘法运算符

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

one of

12.7.1静态语义: 是函数定义

Return false.

12.7.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.7.3运行时语义: 估值

Let left be the result of evaluating MultiplicativeExpression.
Let leftValue be ? GetValue(left).
Let right be the result of evaluating ExponentiationExpression.
Let rightValue be ? GetValue(right).
Let lnum be ? ToNumber(leftValue).
Let rnum be ? ToNumber(rightValue).
Return the result of applying the MultiplicativeOperator (*, /, or %) to lnum and rnum as specified in 12.7.3.1, 12.7.3.2, or 12.7.3.3.

12.7.3.1Applying the `*` 运算符

The * MultiplicativeOperator performs multiplication, producing the product of its operands. Multiplication is commutative. Multiplication is not always associative in ES, because of finite precision.

The result of a floating-point multiplication is governed by the rules of IEEE 754-2008 binary double-precision arithmetic:

If either operand is NaN, the result is NaN.
The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
Multiplication of an infinity by a zero results in NaN.
Multiplication of an infinity by an infinity results in an infinity. The sign is determined by the rule already stated above.
Multiplication of an infinity by a finite nonzero value results in a signed infinity. The sign is determined by the rule already stated above.
In the remaining cases, where neither an infinity nor NaN is involved, the product is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the result is then a zero of appropriate sign. The ES language requires support of gradual underflow as defined by IEEE 754-2008.

12.7.3.2Applying the `/` 运算符

The / MultiplicativeOperator performs division, producing the quotient of its operands. The left operand is the dividend and the right operand is the divisor. ES does not perform integer division. The operands and result of all division operations are double-precision floating-point numbers. The result of division is determined by the specification of IEEE 754-2008 arithmetic:

If either operand is NaN, the result is NaN.
The sign of the result is positive if both operands have the same sign, negative if the operands have different signs.
Division of an infinity by an infinity results in NaN.
Division of an infinity by a zero results in an infinity. The sign is determined by the rule already stated above.
Division of an infinity by a nonzero finite value results in a signed infinity. The sign is determined by the rule already stated above.
Division of a finite value by an infinity results in zero. The sign is determined by the rule already stated above.
Division of a zero by a zero results in NaN; division of zero by any other finite value results in zero, with the sign determined by the rule already stated above.
Division of a nonzero finite value by a zero results in a signed infinity. The sign is determined by the rule already stated above.
In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the quotient is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows; the result is then an infinity of appropriate sign. If the magnitude is too small to represent, the operation underflows and the result is a zero of the appropriate sign. The ES language requires support of gradual underflow as defined by IEEE 754-2008.

12.7.3.3Applying the `%` 运算符

The % MultiplicativeOperator yields the remainder of its operands from an implied division; the left operand is the dividend and the right operand is the divisor.

Note

In C and C++, the remainder 运算符 accepts only integral operands; in ES, it also accepts floating-point operands.

The result of a floating-point remainder operation as computed by the % 运算符 is not the same as the “remainder” operation defined by IEEE 754-2008. The IEEE 754-2008 “remainder” operation computes the remainder from a rounding division, not a truncating division, and so its behaviour is not analogous to that of the usual integer remainder 运算符. Instead the ES language defines % on floating-point operations to behave in a manner analogous to that of the Java integer remainder 运算符; this may be compared with the C library function fmod.

The result of an ES floating-point remainder operation is determined by the rules of IEEE arithmetic:

If either operand is NaN, the result is NaN.
The sign of the result equals the sign of the dividend.
If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
If the dividend is finite and the divisor is an infinity, the result equals the dividend.
If the dividend is a zero and the divisor is nonzero and finite, the result is the same as the dividend.
In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, the floating-point remainder r from a dividend n and a divisor d is defined by the mathematical relation r = n - (d × q) where q is an integer that is negative only if n/d is negative and positive only if n/d is positive, and whose magnitude is as large as possible without exceeding the magnitude of the true mathematical quotient of n and d. r is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.

12.8加法运算符

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

12.8.1静态语义: 是函数定义

Return false.

12.8.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.8.3加运算符 ( `+` )

Note

加运算符 either performs string concatenation or numeric addition.

12.8.3.1运行时语义: 估值

Let lref be the result of evaluating AdditiveExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating MultiplicativeExpression.
Let rval be ? GetValue(rref).
Let lprim be ? ToPrimitive(lval).
Let rprim be ? ToPrimitive(rval).
If Type(lprim) is String or Type(rprim) is String, then
1. Let lstr be ? ToString(lprim).
2. Let rstr be ? ToString(rprim).
3. Return the string-concatenation of lstr and rstr.
Let lnum be ? ToNumber(lprim).
Let rnum be ? ToNumber(rprim).
Return the result of applying the addition operation to lnum and rnum. See the Note below 12.8.5.

Note 1

No hint is provided in the calls to ToPrimitive in steps 5 and 6. All standard objects except 日期对象 handle the absence of a hint as if the hint Number were given; 日期对象 handle the absence of a hint as if the hint String were given. 外来对象 may handle the absence of a hint in some other manner.

Note 2

Step 7 differs from step 3 of the 抽象关系比较算法, by using the 逻辑或运算 instead of the 逻辑与运算.

12.8.4减运算符 ( `-` )

12.8.4.1运行时语义: 估值

Let lref be the result of evaluating AdditiveExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating MultiplicativeExpression.
Let rval be ? GetValue(rref).
Let lnum be ? ToNumber(lval).
Let rnum be ? ToNumber(rval).
Return the result of applying the subtraction operation to lnum and rnum. See the note below 12.8.5.

12.8.5对数字应用加法运算符

The + 运算符 performs addition when applied to two operands of numeric type, producing the sum of the operands. The - 运算符 performs subtraction, producing the difference of two numeric operands.

Addition is a commutative operation, but not always associative.

The result of an addition is determined using the rules of IEEE 754-2008 binary double-precision arithmetic:

If either operand is NaN, the result is NaN.
The sum of two infinities of opposite sign is NaN.
The sum of two infinities of the same sign is the infinity of that sign.
The sum of an infinity and a finite value is equal to the infinite operand.
The sum of two negative zeroes is -0. The sum of two positive zeroes, or of two zeroes of opposite sign, is +0.
The sum of a zero and a nonzero finite value is equal to the nonzero operand.
The sum of two nonzero finite values of the same magnitude and opposite sign is +0.
In the remaining cases, where neither an infinity, nor a zero, nor NaN is involved, and the operands have the same sign or have different magnitudes, the sum is computed and rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. If the magnitude is too large to represent, the operation overflows and the result is then an infinity of appropriate sign. The ES language requires support of gradual underflow as defined by IEEE 754-2008.

Note

The - 运算符 performs subtraction when applied to two operands of numeric type, producing the difference of its operands; the left operand is the minuend and the right operand is the subtrahend. Given numeric operands a and b, it is always the case that a-b produces the same result as a+(-b).

12.9位移运算符

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

>>>

[?Yield, ?Await]

12.9.1静态语义: 是函数定义

>>>

Return false.

12.9.2静态语义: IsValidSimpleAssignmentTarget

>>>

Return false.

12.9.3左移运算符 ( `<<` )

Note

Performs a bitwise left shift operation on the left operand by the amount specified by the right operand.

12.9.3.1运行时语义: 估值

Let lref be the result of evaluating ShiftExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating AdditiveExpression.
Let rval be ? GetValue(rref).
Let lnum be ? ToInt32(lval).
Let rnum be ? ToUint32(rval).
Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer.

12.9.4有符号右移运算符 ( `>>` )

Note

Performs a sign-filling bitwise right shift operation on the left operand by the amount specified by the right operand.

12.9.4.1运行时语义: 估值

Let lref be the result of evaluating ShiftExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating AdditiveExpression.
Let rval be ? GetValue(rref).
Let lnum be ? ToInt32(lval).
Let rnum be ? ToUint32(rval).
Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
Return the result of performing a sign-extending right shift of lnum by shiftCount bits. The most significant bit is propagated. The result is a signed 32-bit integer.

12.9.5无符号右移运算符 ( `>>>` )

Note

Performs a zero-filling bitwise right shift operation on the left operand by the amount specified by the right operand.

12.9.5.1运行时语义: 估值

>>>

Let lref be the result of evaluating ShiftExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating AdditiveExpression.
Let rval be ? GetValue(rref).
Let lnum be ? ToUint32(lval).
Let rnum be ? ToUint32(rval).
Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F.
Return the result of performing a zero-filling right shift of lnum by shiftCount bits. Vacated bits are filled with zero. The result is an unsigned 32-bit integer.

12.10关系运算符

Note 1

The result of evaluating a relational 运算符 is always of type Boolean, reflecting whether the relationship named by the 运算符 holds between its two operands.

Syntax

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

instanceof

[?Yield, ?Await]

[+In]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

Note 2

The _[In] grammar parameter is needed to avoid confusing the in 运算符 in a relational expression with the in 运算符 in a for statement.

12.10.1静态语义: 是函数定义

instanceof

Return false.

12.10.2静态语义: IsValidSimpleAssignmentTarget

instanceof

Return false.

12.10.3运行时语义: 估值

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 抽象关系比较 lval < rval.
ReturnIfAbrupt(r).
If r is undefined, return false. Otherwise, return r.

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 抽象关系比较 rval < lval with LeftFirst equal to false.
ReturnIfAbrupt(r).
If r is undefined, return false. Otherwise, return r.

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 抽象关系比较 rval < lval with LeftFirst equal to false.
ReturnIfAbrupt(r).
If r is true or undefined, return false. Otherwise, return true.

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 抽象关系比较 lval < rval.
ReturnIfAbrupt(r).
If r is true or undefined, return false. Otherwise, return true.

instanceof

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
Return ? InstanceofOperator(lval, rval).

Let lref be the result of evaluating RelationalExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating ShiftExpression.
Let rval be ? GetValue(rref).
If Type(rval) is not Object, 抛出一个 TypeError 异常.
Return ? HasProperty(rval, ToPropertyKey(lval)).

12.10.4运行时语义: InstanceofOperator ( `V`, `target` )

The 抽象操作 InstanceofOperator(V, target) implements the generic 算法 for determining if ES 值 V is an instance of object target either by consulting target's @@hasinstance method or, if absent, determining whether the value of target's prototype property is present in V's prototype chain. This 抽象操作执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let instOfHandler be ? GetMethod(target, @@hasInstance).
If instOfHandler is not undefined, then
1. Return ToBoolean(? Call(instOfHandler, target, « V »)).
If IsCallable(target) is false, 抛出一个 TypeError 异常.
Return ? OrdinaryHasInstance(target, V).

Note

Steps 4 and 5 provide compatibility with previous editions of ES that did not use a @@hasInstance method to define the instanceof 运算符语义. If an object does not define or inherit @@hasInstance it uses the default instanceof 语义.

12.11相等运算符

Note

The result of evaluating an equality 运算符 is always of type Boolean, reflecting whether the relationship named by the 运算符 holds between its two operands.

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

===

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

!==

[?In, ?Yield, ?Await]

12.11.1静态语义: 是函数定义

===

!==

Return false.

12.11.2静态语义: IsValidSimpleAssignmentTarget

===

!==

Return false.

12.11.3运行时语义: 估值

Let lref be the result of evaluating EqualityExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating RelationalExpression.
Let rval be ? GetValue(rref).
Return the result of performing 抽象相等比较 rval == lval.

Let lref be the result of evaluating EqualityExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating RelationalExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 抽象相等比较 rval == lval.
If r is true, return false. Otherwise, return true.

===

Let lref be the result of evaluating EqualityExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating RelationalExpression.
Let rval be ? GetValue(rref).
Return the result of performing 严格相等比较 rval === lval.

!==

Let lref be the result of evaluating EqualityExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating RelationalExpression.
Let rval be ? GetValue(rref).
Let r be the result of performing 严格相等比较 rval === lval.
If r is true, return false. Otherwise, return true.

Note 1

Given the above definition of equality:

String comparison can be forced by: "" + a == "" + b.
Numeric comparison can be forced by: +a == +b.
Boolean comparison can be forced by: !a == !b.

Note 2

The 相等运算符 maintain the following 不变量:

A != B is equivalent to !(A == B).
A == B is equivalent to B == A, except in the order of 估值 of A and B.

Note 3

The equality 运算符 is not always transitive. 例如, there might be two distinct 字符串对象, each representing the same String 值; each String 对象 would be considered equal to the String 值 by the == 运算符, but the two 字符串对象 would not be equal to each other. 例如:

new String("a") == "a" and "a" == new String("a") are both true.
new String("a") == new String("a") is false.

Note 4

Comparison of Strings uses a simple equality test on sequences of 代码单元 values. There is no attempt to use the more complex, semantically oriented definitions of character or string equality and collating order defined in the Unicode specification. Therefore Strings values that are canonically equal according to the Unicode standard could test as unequal. In effect this 算法 assumes that both Strings are already in normalized form.

12.12二进制位运算符

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

12.12.1静态语义: 是函数定义

Return false.

12.12.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.12.3运行时语义: 估值

The production A:A@B , where @ is one of the bitwise operators in the productions above, is evaluated as follows:

Let lref be the result of evaluating A.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating B.
Let rval be ? GetValue(rref).
Let lnum be ? ToInt32(lval).
Let rnum be ? ToInt32(rval).
Return the result of applying the bitwise 运算符 @ to lnum and rnum. The result is a signed 32-bit integer.

12.13二进制逻辑运算符

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

Note

The value produced by a && or || 运算符 is not necessarily of type Boolean. The value produced will always be the value of one of the two operand expressions.

12.13.1静态语义: 是函数定义

Return false.

12.13.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.13.3运行时语义: 估值

Let lref be the result of evaluating LogicalANDExpression.
Let lval be ? GetValue(lref).
Let lbool be ToBoolean(lval).
If lbool is false, return lval.
Let rref be the result of evaluating BitwiseORExpression.
Return ? GetValue(rref).

Let lref be the result of evaluating LogicalORExpression.
Let lval be ? GetValue(lref).
Let lbool be ToBoolean(lval).
If lbool is true, return lval.
Let rref be the result of evaluating LogicalANDExpression.
Return ? GetValue(rref).

12.14条件运算符 ( `? :` )

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

Note

The grammar for a ConditionalExpression in ES is slightly different from that in C and Java, which each allow the second subexpression to be an Expression but restrict the third expression to be a ConditionalExpression. The motivation for this difference in ES is to allow an assignment expression to be governed by either arm of a conditional and to eliminate the confusing and fairly useless case of a comma expression as the centre expression.

12.14.1静态语义: 是函数定义

Return false.

12.14.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.14.3运行时语义: 估值

Let lref be the result of evaluating LogicalORExpression.
Let lval be ToBoolean(? GetValue(lref)).
If lval is true, then
1. Let trueRef be the result of evaluating the first AssignmentExpression.
2. Return ? GetValue(trueRef).
Else,
1. Let falseRef be the result of evaluating the second AssignmentExpression.
2. Return ? GetValue(falseRef).

12.15赋值运算符

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[+Yield]

[?In, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

one of

<<=

>>=

>>>=

**=

12.15.1静态语义: 早期错误

这是一个句法错误如果 LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and LeftHandSideExpression is not covering an AssignmentPattern.
It is an early Reference Error if LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.

It is an early Reference Error if IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.

12.15.2静态语义: 是函数定义

Return true.

Return false.

12.15.3静态语义: IsValidSimpleAssignmentTarget

Return false.

12.15.4运行时语义: 估值

If LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral, then
1. Let lref be the result of evaluating LeftHandSideExpression.
2. ReturnIfAbrupt(lref).
3. Let rref be the result of evaluating AssignmentExpression.
4. Let rval be ? GetValue(rref).
5. If IsAnonymousFunctionDefinition(AssignmentExpression) and 是标识符引用 of LeftHandSideExpression are both true, then
  1. Let hasNameProperty be ? HasOwnProperty(rval, "name").
  2. If hasNameProperty is false, perform SetFunctionName(rval, GetReferencedName(lref)).
6. Perform ? PutValue(lref, rval).
7. Return rval.
Let assignmentPattern be the AssignmentPattern that is covered by LeftHandSideExpression.
Let rref be the result of evaluating AssignmentExpression.
Let rval be ? GetValue(rref).
Perform ? DestructuringAssignmentEvaluation of assignmentPattern using rval as the argument.
Return rval.

Let lref be the result of evaluating LeftHandSideExpression.
Let lval be ? GetValue(lref).
Let rref be the result of evaluating AssignmentExpression.
Let rval be ? GetValue(rref).
Let op be the @ where AssignmentOperator is @=.
Let r be the result of applying op to lval and rval as if evaluating the expression lval op rval.
Perform ? PutValue(lref, r).
Return r.

Note

When an assignment occurs within 严格模式代码, it is a runtime error if lref in step 1.f of the first 算法 or step 7 of the second 算法 it is an unresolvable reference. If it is, a ReferenceError 异常 is thrown. The LeftHandSideExpression also may not be a reference to a 数据属性 with the 特性 value {[[Writable]]: false}, to an 访问器属性 with the 特性 value {[[Set]]: undefined}, nor to a non-existent property of an object for which the IsExtensible predicate returns the value false. In these cases a TypeError 异常 is thrown.

12.15.5解构赋值

Supplemental Syntax

In certain circumstances when processing an instance of the production AssignmentExpression:LeftHandSideExpression=AssignmentExpression the following grammar is used to refine the interpretation of LeftHandSideExpression.

AssignmentPattern

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

[?Yield, ?Await]

opt

}

[Yield, Await]

[

opt

[?Yield, ?Await]

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

[?Yield, ?Await]

opt

]

[Yield, Await]

...

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

...

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

12.15.5.1静态语义: 早期错误

opt

这是一个句法错误如果 IsValidSimpleAssignmentTarget of IdentifierReference is false.

...

这是一个句法错误如果 DestructuringAssignmentTarget is an ArrayLiteral or an ObjectLiteral.

这是一个句法错误如果 LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if LeftHandSideExpression is not covering an AssignmentPattern.
这是一个句法错误如果 LeftHandSideExpression is neither an ObjectLiteral nor an ArrayLiteral and IsValidSimpleAssignmentTarget(LeftHandSideExpression) is false.

12.15.5.2运行时语义: DestructuringAssignmentEvaluation

With parameter value.

{

}

Perform ? RequireObjectCoercible(value).
Return NormalCompletion(empty).

{

}

{

}

Perform ? RequireObjectCoercible(value).
Perform ? PropertyDestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
Return NormalCompletion(empty).

[

]

Let iteratorRecord be ? GetIterator(value).
Return ? IteratorClose(iteratorRecord, NormalCompletion(empty)).

[

]

Let iteratorRecord be ? GetIterator(value).
Let result be the result of performing IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
Return result.

[

opt

]

Let iteratorRecord be ? GetIterator(value).
If Elision is present, then
1. Let status be the result of performing IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
2. If status is an abrupt completion, then
  1. Assert: iteratorRecord.[[Done]] is true.
  2. Return Completion(status).
Let result be the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with iteratorRecord as the argument.
If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
Return result.

[

]

Let iteratorRecord be ? GetIterator(value).
Let result be the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElementList using iteratorRecord as the argument.
If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
Return result.

[

opt

opt

]

Let iteratorRecord be ? GetIterator(value).
Let status be the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElementList using iteratorRecord as the argument.
If status is an abrupt completion, then
1. If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
2. Return Completion(status).
If Elision is present, then
1. Set status to the result of performing IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
2. If status is an abrupt completion, then
  1. Assert: iteratorRecord.[[Done]] is true.
  2. Return Completion(status).
If AssignmentRestElement is present, then
1. Set status to the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentRestElement with iteratorRecord as the argument.
If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, status).
Return Completion(status).

{

}

Let excludedNames be a new empty List.
Return the result of performing RestDestructuringAssignmentEvaluation of AssignmentRestProperty with value and excludedNames as the arguments.

{

}

Let excludedNames be the result of performing ? PropertyDestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
Return the result of performing RestDestructuringAssignmentEvaluation of AssignmentRestProperty with value and excludedNames as the arguments.

12.15.5.3运行时语义: PropertyDestructuringAssignmentEvaluation

With parameter value.

Note

The following operations collect a list of all destructured property names.

Let propertyNames be the result of performing ? PropertyDestructuringAssignmentEvaluation for AssignmentPropertyList using value as the argument.
Let nextNames be the result of performing ? PropertyDestructuringAssignmentEvaluation for AssignmentProperty using value as the argument.
Append each item in nextNames to the end of propertyNames.
Return propertyNames.

opt

Let P be 字符值 of IdentifierReference.
Let lref be ? ResolveBinding(P).
Let v be ? GetV(value, P).
If 初始化器opt is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Set v to ? GetValue(defaultValue).
3. If IsAnonymousFunctionDefinition(初始化器) is true, then
  1. Let hasNameProperty be ? HasOwnProperty(v, "name").
  2. If hasNameProperty is false, perform SetFunctionName(v, P).
Perform ? PutValue(lref, v).
Return a new List containing P.

Let name be the result of evaluating PropertyName.
ReturnIfAbrupt(name).
Perform ? KeyedDestructuringAssignmentEvaluation of AssignmentElement with value and name as the arguments.
Return a new List containing name.

12.15.5.4运行时语义: RestDestructuringAssignmentEvaluation

With parameters value and excludedNames.

...

Let lref be the result of evaluating DestructuringAssignmentTarget.
ReturnIfAbrupt(lref).
Let restObj be ObjectCreate(%ObjectPrototype%).
Perform ? CopyDataProperties(restObj, value, excludedNames).
Return PutValue(lref, restObj).

12.15.5.5运行时语义: IteratorDestructuringAssignmentEvaluation

With parameter iteratorRecord.

Return the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElisionElement using iteratorRecord as the argument.

Perform ? IteratorDestructuringAssignmentEvaluation of AssignmentElementList using iteratorRecord as the argument.
Return the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElisionElement using iteratorRecord as the argument.

Return the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElement with iteratorRecord as the argument.

Perform ? IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
Return the result of performing IteratorDestructuringAssignmentEvaluation of AssignmentElement with iteratorRecord as the argument.

If iteratorRecord.[[Done]] is false, then
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
Return NormalCompletion(empty).

Perform ? IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
If iteratorRecord.[[Done]] is false, then
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
Return NormalCompletion(empty).

opt

If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
1. Let lref be the result of evaluating DestructuringAssignmentTarget.
2. ReturnIfAbrupt(lref).
If iteratorRecord.[[Done]] is false, then
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
5. Else,
  1. Let value be IteratorValue(next).
  2. If value is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(value).
If iteratorRecord.[[Done]] is true, let value be undefined.
If 初始化器 is present and value is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Let v be ? GetValue(defaultValue).
Else, let v be value.
If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
1. Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
2. Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with v as the argument.
If 初始化器 is present and value is undefined and IsAnonymousFunctionDefinition(初始化器) and 是标识符引用 of DestructuringAssignmentTarget are both true, then
1. Let hasNameProperty be ? HasOwnProperty(v, "name").
2. If hasNameProperty is false, perform SetFunctionName(v, GetReferencedName(lref)).
Return ? PutValue(lref, v).

Note

Left to right 估值 order is maintained by evaluating a DestructuringAssignmentTarget that is not a destructuring pattern prior to accessing the 迭代器 or evaluating the 初始化器.

...

If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
1. Let lref be the result of evaluating DestructuringAssignmentTarget.
2. ReturnIfAbrupt(lref).
Let A be ! ArrayCreate(0).
Let n be 0.
Repeat, while iteratorRecord.[[Done]] is false,
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
5. Else,
  1. Let nextValue be IteratorValue(next).
  2. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(nextValue).
  4. Let status be CreateDataProperty(A, ! ToString(n), nextValue).
  5. Assert: status is true.
  6. Increment n by 1.
If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
1. Return ? PutValue(lref, A).
Let nestedAssignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
Return the result of performing DestructuringAssignmentEvaluation of nestedAssignmentPattern with A as the argument.

12.15.5.6运行时语义: KeyedDestructuringAssignmentEvaluation

With parameters value and propertyName.

opt

If DestructuringAssignmentTarget is neither an ObjectLiteral nor an ArrayLiteral, then
1. Let lref be the result of evaluating DestructuringAssignmentTarget.
2. ReturnIfAbrupt(lref).
Let v be ? GetV(value, propertyName).
If 初始化器 is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Let rhsValue be ? GetValue(defaultValue).
Else, let rhsValue be v.
If DestructuringAssignmentTarget is an ObjectLiteral or an ArrayLiteral, then
1. Let assignmentPattern be the AssignmentPattern that is covered by DestructuringAssignmentTarget.
2. Return the result of performing DestructuringAssignmentEvaluation of assignmentPattern with rhsValue as the argument.
If 初始化器 is present and v is undefined and IsAnonymousFunctionDefinition(初始化器) and 是标识符引用 of DestructuringAssignmentTarget are both true, then
1. Let hasNameProperty be ? HasOwnProperty(rhsValue, "name").
2. If hasNameProperty is false, perform SetFunctionName(rhsValue, GetReferencedName(lref)).
Return ? PutValue(lref, rhsValue).

12.16逗号运算符 ( `,` )

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

12.16.1静态语义: 是函数定义

Return false.

12.16.2静态语义: IsValidSimpleAssignmentTarget

Return false.

12.16.3运行时语义: 估值

Let lref be the result of evaluating Expression.
Perform ? GetValue(lref).
Let rref be the result of evaluating AssignmentExpression.
Return ? GetValue(rref).

Note

GetValue must be called even though its value is not used because it may have observable side-effects.

13ES 语言: 语句和声明

Syntax

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await]

[+Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await, ~Default]

[?Yield, ?Await, ~Default]

[+In, ?Yield, ?Await]

[Yield, Await, Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

13.1语句语义

13.1.1静态语义: ContainsDuplicateLabels

With parameter labelSet.

Return false.

13.1.2静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

Return false.

13.1.3静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

Return false.

Let newIterationSet be a copy of iterationSet with all the elements of labelSet appended.
Return ContainsUndefinedContinueTarget of IterationStatement with arguments newIterationSet and « ».

13.1.4静态语义: DeclarationPart

Return FunctionDeclaration.

Return GeneratorDeclaration.

Return AsyncFunctionDeclaration.

Return AsyncGeneratorDeclaration.

Return ClassDeclaration.

Return LexicalDeclaration.

13.1.5静态语义: VarDeclaredNames

Return a new empty List.

13.1.6静态语义: VarScopedDeclarations

Return a new empty List.

13.1.7运行时语义: LabelledEvaluation

With parameter labelSet.

Let stmtResult be the result of performing LabelledEvaluation of IterationStatement with argument labelSet.
If stmtResult.[[Type]] is break, then
1. If stmtResult.[[Target]] is empty, then
  1. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
  2. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
Return Completion(stmtResult).

Let stmtResult be the result of evaluating SwitchStatement.
If stmtResult.[[Type]] is break, then
1. If stmtResult.[[Target]] is empty, then
  1. If stmtResult.[[Value]] is empty, set stmtResult to NormalCompletion(undefined).
  2. Else, set stmtResult to NormalCompletion(stmtResult.[[Value]]).
Return Completion(stmtResult).

Note

A BreakableStatement is one that can be exited via an unlabelled BreakStatement.

13.1.8运行时语义: 估值

Return NormalCompletion(empty).

Return the result of evaluating FunctionDeclaration.

Let newLabelSet be a new empty List.
Return the result of performing LabelledEvaluation of this BreakableStatement with argument newLabelSet.

13.2Block

Syntax

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

{

[?Yield, ?Await, ?Return]

opt

}

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

13.2.1静态语义: 早期错误

{

}

这是一个句法错误如果 the LexicallyDeclaredNames of StatementList contains any duplicate entries.
这是一个句法错误如果 any element of the LexicallyDeclaredNames of StatementList also occurs in the VarDeclaredNames of StatementList.

13.2.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

{

}

Return false.

Let hasDuplicates be ContainsDuplicateLabels of StatementList with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of StatementListItem with argument labelSet.

Return false.

13.2.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

{

}

Return false.

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of StatementList with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of StatementListItem with argument labelSet.

Return false.

13.2.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

{

}

Return false.

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of StatementList with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of StatementListItem with arguments iterationSet and « ».

Return false.

13.2.5静态语义: LexicallyDeclaredNames

{

}

Return a new empty List.

Let names be LexicallyDeclaredNames of StatementList.
Append to names the elements of the LexicallyDeclaredNames of StatementListItem.
Return names.

If Statement is Statement:LabelledStatement , return LexicallyDeclaredNames of LabelledStatement.
Return a new empty List.

Return the 绑定名 of Declaration.

13.2.6静态语义: LexicallyScopedDeclarations

Let declarations be LexicallyScopedDeclarations of StatementList.
Append to declarations the elements of the LexicallyScopedDeclarations of StatementListItem.
Return declarations.

If Statement is Statement:LabelledStatement , return LexicallyScopedDeclarations of LabelledStatement.
Return a new empty List.

Return a new List containing DeclarationPart of Declaration.

13.2.7静态语义: TopLevelLexicallyDeclaredNames

Let names be TopLevelLexicallyDeclaredNames of StatementList.
Append to names the elements of the TopLevelLexicallyDeclaredNames of StatementListItem.
Return names.

Return a new empty List.

If Declaration is Declaration:HoistableDeclaration , then
1. Return « ».
Return the 绑定名 of Declaration.

Note

At the top level of a function, or script, 函数声明 are treated like var declarations rather than like lexical declarations.

13.2.8静态语义: TopLevelLexicallyScopedDeclarations

{

}

Return a new empty List.

Let declarations be TopLevelLexicallyScopedDeclarations of StatementList.
Append to declarations the elements of the TopLevelLexicallyScopedDeclarations of StatementListItem.
Return declarations.

Return a new empty List.

If Declaration is Declaration:HoistableDeclaration , then
1. Return « ».
Return a new List containing Declaration.

13.2.9静态语义: TopLevelVarDeclaredNames

{

}

Return a new empty List.

Let names be TopLevelVarDeclaredNames of StatementList.
Append to names the elements of the TopLevelVarDeclaredNames of StatementListItem.
Return names.

If Declaration is Declaration:HoistableDeclaration , then
1. Return the 绑定名 of HoistableDeclaration.
Return a new empty List.

If Statement is Statement:LabelledStatement , return TopLevelVarDeclaredNames of Statement.
Return VarDeclaredNames of Statement.

Note

At the top level of a function or script, inner 函数声明 are treated like var declarations.

13.2.10静态语义: TopLevelVarScopedDeclarations

{

}

Return a new empty List.

Let declarations be TopLevelVarScopedDeclarations of StatementList.
Append to declarations the elements of the TopLevelVarScopedDeclarations of StatementListItem.
Return declarations.

If Statement is Statement:LabelledStatement , return TopLevelVarScopedDeclarations of Statement.
Return VarScopedDeclarations of Statement.

If Declaration is Declaration:HoistableDeclaration , then
1. Let declaration be DeclarationPart of HoistableDeclaration.
2. Return « declaration ».
Return a new empty List.

13.2.11静态语义: VarDeclaredNames

{

}

Return a new empty List.

Let names be VarDeclaredNames of StatementList.
Append to names the elements of the VarDeclaredNames of StatementListItem.
Return names.

Return a new empty List.

13.2.12静态语义: VarScopedDeclarations

{

}

Return a new empty List.

Let declarations be VarScopedDeclarations of StatementList.
Append to declarations the elements of the VarScopedDeclarations of StatementListItem.
Return declarations.

Return a new empty List.

13.2.13运行时语义: 估值

{

}

Return NormalCompletion(empty).

{

}

Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let blockEnv be NewDeclarativeEnvironment(oldEnv).
Perform BlockDeclarationInstantiation(StatementList, blockEnv).
Set the 运行时执行上下文's LexicalEnvironment to blockEnv.
Let blockValue be the result of evaluating StatementList.
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Return blockValue.

Note 1

No matter how control leaves the Block the LexicalEnvironment is always restored to its former state.

Let sl be the result of evaluating StatementList.
ReturnIfAbrupt(sl).
Let s be the result of evaluating StatementListItem.
Return Completion(UpdateEmpty(s, sl)).

Note 2

The value of a StatementList is the value of the last value-producing item in the StatementList. 例如, the following calls to the eval function all return the value 1:

eval("1;;;;;")
                              eval("1;{}")
                              eval("1;var a;")

13.2.14运行时语义: BlockDeclarationInstantiation( `code`, `env` )

Note

When a Block or CaseBlock is evaluated a new declarative 环境记录 is created and bindings for each block scoped variable, constant, function, or class declared in the block are instantiated in the 环境记录.

BlockDeclarationInstantiation is performed as follows using arguments code and env. code is the 解析节点 corresponding to the body of the block. env is the 词法环境 in which bindings are to be created.

Let envRec be env's EnvironmentRecord.
Assert: envRec is a declarative 环境记录.
Let declarations be the LexicallyScopedDeclarations of code.
For each element d in declarations, do
1. For each element dn of the 绑定名 of d, do
  1. If IsConstantDeclaration of d is true, then
    1. Perform ! envRec.CreateImmutableBinding(dn, true).
  2. Else,
    1. Perform ! envRec.CreateMutableBinding(dn, false).
2. If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
  1. Let fn be the sole element of the 绑定名 of d.
  2. Let fo be the result of performing InstantiateFunctionObject for d with argument env.
  3. Perform envRec.InitializeBinding(fn, fo).

13.3声明和变量语句

13.3.1Let 和 Const 声明

Note

let and const declarations define variables that are scoped to the 运行时执行上下文's LexicalEnvironment. The variables are created when their containing 词法环境 is instantiated but may not be accessed in any way until the variable's LexicalBinding is evaluated. A variable defined by a LexicalBinding with an 初始化器 is assigned the value of its 初始化器's AssignmentExpression when the LexicalBinding is evaluated, not when the variable is created. If a LexicalBinding in a let declaration does not have an 初始化器 the variable is assigned the value undefined when the LexicalBinding is evaluated.

Syntax

[In, Yield, Await]

[?In, ?Yield, ?Await]

;

let

const

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?In, ?Yield, ?Await]

13.3.1.1静态语义: 早期错误

;

这是一个句法错误如果 the 绑定名 of BindingList contains "let".
这是一个句法错误如果 the 绑定名 of BindingList contains any duplicate entries.

opt

这是一个句法错误如果初始化器 is not present and IsConstantDeclaration of the LexicalDeclaration containing this LexicalBinding is true.

13.3.1.2静态语义: 绑定名

;

Return the 绑定名 of BindingList.

Let names be the 绑定名 of BindingList.
Append to names the elements of the 绑定名 of LexicalBinding.
Return names.

opt

Return the 绑定名 of BindingIdentifier.

Return the 绑定名 of BindingPattern.

13.3.1.3静态语义: IsConstantDeclaration

;

Return IsConstantDeclaration of LetOrConst.

let

Return false.

const

Return true.

13.3.1.4运行时语义: 估值

;

Let next be the result of evaluating BindingList.
ReturnIfAbrupt(next).
Return NormalCompletion(empty).

Let next be the result of evaluating BindingList.
ReturnIfAbrupt(next).
Return the result of evaluating LexicalBinding.

Let lhs be ResolveBinding(字符值 of BindingIdentifier).
Return InitializeReferencedBinding(lhs, undefined).

Note

A 静态语义 rule ensures that this form of LexicalBinding never occurs in a const declaration.

Let bindingId be 字符值 of BindingIdentifier.
Let lhs be ResolveBinding(bindingId).
Let rhs be the result of evaluating 初始化器.
Let value be ? GetValue(rhs).
If IsAnonymousFunctionDefinition(初始化器) is true, then
1. Let hasNameProperty be ? HasOwnProperty(value, "name").
2. If hasNameProperty is false, perform SetFunctionName(value, bindingId).
Return InitializeReferencedBinding(lhs, value).

Let rhs be the result of evaluating 初始化器.
Let value be ? GetValue(rhs).
Let env be the 运行时执行上下文's LexicalEnvironment.
Return the result of performing 绑定初始化 for BindingPattern using value and env as the arguments.

13.3.2变量语句

Note

A var statement declares variables that are scoped to the 运行时执行上下文's VariableEnvironment. Var variables are created when their containing 词法环境 is instantiated and are initialized to undefined when created. Within the scope of any VariableEnvironment a common BindingIdentifier may appear in more than one VariableDeclaration but those declarations collectively define only one variable. A variable defined by a VariableDeclaration with an 初始化器 is assigned the value of its 初始化器's AssignmentExpression when the VariableDeclaration is executed, not when the variable is created.

Syntax

[Yield, Await]

var

[+In, ?Yield, ?Await]

;

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?In, ?Yield, ?Await]

13.3.2.1静态语义: 绑定名

Let names be 绑定名 of VariableDeclarationList.
Append to names the elements of 绑定名 of VariableDeclaration.
Return names.

opt

Return the 绑定名 of BindingIdentifier.

Return the 绑定名 of BindingPattern.

13.3.2.2静态语义: VarDeclaredNames

var

;

Return 绑定名 of VariableDeclarationList.

13.3.2.3静态语义: VarScopedDeclarations

Return a new List containing VariableDeclaration.

Let declarations be VarScopedDeclarations of VariableDeclarationList.
Append VariableDeclaration to declarations.
Return declarations.

13.3.2.4运行时语义: 估值

var

;

Let next be the result of evaluating VariableDeclarationList.
ReturnIfAbrupt(next).
Return NormalCompletion(empty).

Let next be the result of evaluating VariableDeclarationList.
ReturnIfAbrupt(next).
Return the result of evaluating VariableDeclaration.

Return NormalCompletion(empty).

Let bindingId be 字符值 of BindingIdentifier.
Let lhs be ? ResolveBinding(bindingId).
Let rhs be the result of evaluating 初始化器.
Let value be ? GetValue(rhs).
If IsAnonymousFunctionDefinition(初始化器) is true, then
1. Let hasNameProperty be ? HasOwnProperty(value, "name").
2. If hasNameProperty is false, perform SetFunctionName(value, bindingId).
Return ? PutValue(lhs, value).

Note

If a VariableDeclaration is nested within a with statement and the BindingIdentifier in the VariableDeclaration is the same as a 属性名 of the binding object of the with statement's object 环境记录, then step 6 will assign value to the property instead of assigning to the VariableEnvironment binding of the Identifier.

Let rhs be the result of evaluating 初始化器.
Let rval be ? GetValue(rhs).
Return the result of performing 绑定初始化 for BindingPattern passing rval and undefined as arguments.

13.3.3解构绑定模式

Syntax

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

[?Yield, ?Await]

opt

}

[Yield, Await]

[

opt

[?Yield, ?Await]

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

[?Yield, ?Await]

opt

]

[Yield, Await]

...

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

...

[?Yield, ?Await]

...

[?Yield, ?Await]

13.3.3.1静态语义: 绑定名

{

}

Return a new empty List.

[

opt

]

Return a new empty List.

[

opt

]

Return the 绑定名 of BindingRestElement.

[

opt

]

Return the 绑定名 of BindingElementList.

[

opt

]

Let names be 绑定名 of BindingElementList.
Append to names the elements of 绑定名 of BindingRestElement.
Return names.

Let names be 绑定名 of BindingPropertyList.
Append to names the elements of 绑定名 of BindingProperty.
Return names.

Let names be 绑定名 of BindingElementList.
Append to names the elements of 绑定名 of BindingElisionElement.
Return names.

opt

Return 绑定名 of BindingElement.

Return the 绑定名 of BindingElement.

opt

Return the 绑定名 of BindingIdentifier.

opt

Return the 绑定名 of BindingPattern.

13.3.3.2静态语义: ContainsExpression

{

}

Return false.

[

opt

]

Return false.

[

opt

]

Return ContainsExpression of BindingRestElement.

[

opt

]

Return ContainsExpression of BindingElementList.

[

opt

]

Let has be ContainsExpression of BindingElementList.
If has is true, return true.
Return ContainsExpression of BindingRestElement.

Let has be ContainsExpression of BindingPropertyList.
If has is true, return true.
Return ContainsExpression of BindingProperty.

Let has be ContainsExpression of BindingElementList.
If has is true, return true.
Return ContainsExpression of BindingElisionElement.

opt

Return ContainsExpression of BindingElement.

Let has be IsComputedPropertyKey of PropertyName.
If has is true, return true.
Return ContainsExpression of BindingElement.

Return true.

Return false.

Return true.

...

Return false.

...

Return ContainsExpression of BindingPattern.

13.3.3.3静态语义: HasInitializer

Return false.

Return true.

Return false.

Return true.

13.3.3.4静态语义: IsSimpleParameterList

Return false.

Return false.

Return true.

Return false.

13.3.3.5运行时语义: 绑定初始化

With parameters value and environment.

Note

When undefined is passed for environment it indicates that a PutValue operation should be used to assign the initialization value. This is the case for formal parameter lists of non-strict functions. In that case the formal parameter bindings are preinitialized in order to deal with the possibility of multiple parameters with the same name.

Perform ? RequireObjectCoercible(value).
Return the result of performing 绑定初始化 for ObjectBindingPattern using value and environment as arguments.

Let iteratorRecord be ? GetIterator(value).
Let result be IteratorBindingInitialization for ArrayBindingPattern using iteratorRecord and environment as arguments.
If iteratorRecord.[[Done]] is false, return ? IteratorClose(iteratorRecord, result).
Return result.

{

}

Return NormalCompletion(empty).

{

}

{

}

Perform ? PropertyBindingInitialization for BindingPropertyList using value and environment as the arguments.
Return NormalCompletion(empty).

{

}

Let excludedNames be a new empty List.
Return the result of performing RestBindingInitialization of BindingRestProperty with value, environment, and excludedNames as the arguments.

{

}

Let excludedNames be the result of performing ? PropertyBindingInitialization of BindingPropertyList using value and environment as arguments.
Return the result of performing RestBindingInitialization of BindingRestProperty with value, environment, and excludedNames as the arguments.

13.3.3.6运行时语义: PropertyBindingInitialization

With parameters value and environment.

Note

These collect a list of all bound property names rather than just empty completion.

Let 绑定名 be the result of performing ? PropertyBindingInitialization for BindingPropertyList using value and environment as arguments.
Let nextNames be the result of performing ? PropertyBindingInitialization for BindingProperty using value and environment as arguments.
Append each item in nextNames to the end of 绑定名.
Return 绑定名.

Let name be the string that is the only element of 绑定名 of SingleNameBinding.
Perform ? KeyedBindingInitialization for SingleNameBinding using value, environment, and name as the arguments.
Return a new List containing name.

Let P be the result of evaluating PropertyName.
ReturnIfAbrupt(P).
Perform ? KeyedBindingInitialization of BindingElement with value, environment, and P as the arguments.
Return a new List containing P.

13.3.3.7运行时语义: RestBindingInitialization

With parameters value, environment, and excludedNames.

...

Let lhs be ? ResolveBinding(字符值 of BindingIdentifier, environment).
Let restObj be ObjectCreate(%ObjectPrototype%).
Perform ? CopyDataProperties(restObj, value, excludedNames).
If environment is undefined, return PutValue(lhs, restObj).
Return InitializeReferencedBinding(lhs, restObj).

13.3.3.8运行时语义: IteratorBindingInitialization

With parameters iteratorRecord and environment.

Note

[

]

Return NormalCompletion(empty).

[

]

Return the result of performing IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.

[

opt

]

If Elision is present, then
1. Perform ? IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
Return the result of performing IteratorBindingInitialization for BindingRestElement with iteratorRecord and environment as arguments.

[

]

Return the result of performing IteratorBindingInitialization for BindingElementList with iteratorRecord and environment as arguments.

[

]

Return the result of performing IteratorBindingInitialization for BindingElementList with iteratorRecord and environment as arguments.

[

]

Perform ? IteratorBindingInitialization for BindingElementList with iteratorRecord and environment as arguments.
Return the result of performing IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.

[

opt

]

Perform ? IteratorBindingInitialization for BindingElementList with iteratorRecord and environment as arguments.
If Elision is present, then
1. Perform ? IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
Return the result of performing IteratorBindingInitialization for BindingRestElement with iteratorRecord and environment as arguments.

Return the result of performing IteratorBindingInitialization for BindingElisionElement with iteratorRecord and environment as arguments.

Perform ? IteratorBindingInitialization for BindingElementList with iteratorRecord and environment as arguments.
Return the result of performing IteratorBindingInitialization for BindingElisionElement using iteratorRecord and environment as arguments.

Return the result of performing IteratorBindingInitialization of BindingElement with iteratorRecord and environment as the arguments.

Perform ? IteratorDestructuringAssignmentEvaluation of Elision with iteratorRecord as the argument.
Return the result of performing IteratorBindingInitialization of BindingElement with iteratorRecord and environment as the arguments.

Return the result of performing IteratorBindingInitialization for SingleNameBinding with iteratorRecord and environment as the arguments.

opt

Let bindingId be 字符值 of BindingIdentifier.
Let lhs be ? ResolveBinding(bindingId, environment).
If iteratorRecord.[[Done]] is false, then
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
5. Else,
  1. Let v be IteratorValue(next).
  2. If v is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(v).
If iteratorRecord.[[Done]] is true, let v be undefined.
If 初始化器 is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Set v to ? GetValue(defaultValue).
3. If IsAnonymousFunctionDefinition(初始化器) is true, then
  1. Let hasNameProperty be ? HasOwnProperty(v, "name").
  2. If hasNameProperty is false, perform SetFunctionName(v, bindingId).
If environment is undefined, return ? PutValue(lhs, v).
Return InitializeReferencedBinding(lhs, v).

opt

If iteratorRecord.[[Done]] is false, then
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, set iteratorRecord.[[Done]] to true.
5. Else,
  1. Let v be IteratorValue(next).
  2. If v is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(v).
If iteratorRecord.[[Done]] is true, let v be undefined.
If 初始化器 is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Set v to ? GetValue(defaultValue).
Return the result of performing 绑定初始化 of BindingPattern with v and environment as the arguments.

...

Let lhs be ? ResolveBinding(字符值 of BindingIdentifier, environment).
Let A be ! ArrayCreate(0).
Let n be 0.
Repeat,
1. If iteratorRecord.[[Done]] is false, then
  1. Let next be IteratorStep(iteratorRecord).
  2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(next).
  4. If next is false, set iteratorRecord.[[Done]] to true.
2. If iteratorRecord.[[Done]] is true, then
  1. If environment is undefined, return ? PutValue(lhs, A).
  2. Return InitializeReferencedBinding(lhs, A).
3. Let nextValue be IteratorValue(next).
4. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
5. ReturnIfAbrupt(nextValue).
6. Let status be CreateDataProperty(A, ! ToString(n), nextValue).
7. Assert: status is true.
8. Increment n by 1.

...

Let A be ! ArrayCreate(0).
Let n be 0.
Repeat,
1. If iteratorRecord.[[Done]] is false, then
  1. Let next be IteratorStep(iteratorRecord).
  2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
  3. ReturnIfAbrupt(next).
  4. If next is false, set iteratorRecord.[[Done]] to true.
2. If iteratorRecord.[[Done]] is true, then
  1. Return the result of performing 绑定初始化 of BindingPattern with A and environment as the arguments.
3. Let nextValue be IteratorValue(next).
4. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
5. ReturnIfAbrupt(nextValue).
6. Let status be CreateDataProperty(A, ! ToString(n), nextValue).
7. Assert: status is true.
8. Increment n by 1.

13.3.3.9运行时语义: KeyedBindingInitialization

With parameters value, environment, and propertyName.

Note

opt

Let v be ? GetV(value, propertyName).
If 初始化器 is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Set v to ? GetValue(defaultValue).
Return the result of performing 绑定初始化 for BindingPattern passing v and environment as arguments.

opt

Let bindingId be 字符值 of BindingIdentifier.
Let lhs be ? ResolveBinding(bindingId, environment).
Let v be ? GetV(value, propertyName).
If 初始化器 is present and v is undefined, then
1. Let defaultValue be the result of evaluating 初始化器.
2. Set v to ? GetValue(defaultValue).
3. If IsAnonymousFunctionDefinition(初始化器) is true, then
  1. Let hasNameProperty be ? HasOwnProperty(v, "name").
  2. If hasNameProperty is false, perform SetFunctionName(v, bindingId).
If environment is undefined, return ? PutValue(lhs, v).
Return InitializeReferencedBinding(lhs, v).

13.4空语句

Syntax

EmptyStatement

;

13.4.1运行时语义: 估值

EmptyStatement

;

Return NormalCompletion(empty).

13.5表达式语句

Syntax

[Yield, Await]

[lookahead ∉ { {, function, async

[no LineTerminator here]

function, class, let [ }]

[+In, ?Yield, ?Await]

;

Note

An ExpressionStatement cannot start with a U+007B (LEFT CURLY BRACKET) because that might make it ambiguous with a Block. An ExpressionStatement cannot start with the function or class 关键字 because that would make it ambiguous with a FunctionDeclaration, a GeneratorDeclaration, or a ClassDeclaration. An ExpressionStatement cannot start with async function because that would make it ambiguous with an AsyncFunctionDeclaration or a AsyncGeneratorDeclaration. An ExpressionStatement cannot start with the two token sequence let [ because that would make it ambiguous with a let LexicalDeclaration whose first LexicalBinding was an ArrayBindingPattern.

13.5.1运行时语义: 估值

;

Let exprRef be the result of evaluating Expression.
Return ? GetValue(exprRef).

13.6`if` 语句

Syntax

[Yield, Await, Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

else

[?Yield, ?Await, ?Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

Each else for which the choice of associated if is ambiguous shall be associated with the nearest possible if that would otherwise have no corresponding else.

13.6.1静态语义: 早期错误

(

)

else

(

)

这是一个句法错误如果 IsLabelledFunction(Statement) is true.

Note

It is only necessary to apply this rule if the extension specified in B.3.2 is implemented.

13.6.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

(

)

else

Let hasDuplicate be ContainsDuplicateLabels of the first Statement with argument labelSet.
If hasDuplicate is true, return true.
Return ContainsDuplicateLabels of the second Statement with argument labelSet.

(

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

13.6.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

(

)

else

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of the first Statement with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of the second Statement with argument labelSet.

(

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

13.6.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

(

)

else

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of the first Statement with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of the second Statement with arguments iterationSet and « ».

(

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

13.6.5静态语义: VarDeclaredNames

(

)

else

Let names be VarDeclaredNames of the first Statement.
Append to names the elements of the VarDeclaredNames of the second Statement.
Return names.

(

)

Return the VarDeclaredNames of Statement.

13.6.6静态语义: VarScopedDeclarations

(

)

else

Let declarations be VarScopedDeclarations of the first Statement.
Append to declarations the elements of the VarScopedDeclarations of the second Statement.
Return declarations.

(

)

Return the VarScopedDeclarations of Statement.

13.6.7运行时语义: 估值

(

)

else

Let exprRef be the result of evaluating Expression.
Let exprValue be ToBoolean(? GetValue(exprRef)).
If exprValue is true, then
1. Let stmtCompletion be the result of evaluating the first Statement.
Else,
1. Let stmtCompletion be the result of evaluating the second Statement.
Return Completion(UpdateEmpty(stmtCompletion, undefined)).

(

)

Let exprRef be the result of evaluating Expression.
Let exprValue be ToBoolean(? GetValue(exprRef)).
If exprValue is false, then
1. Return NormalCompletion(undefined).
Else,
1. Let stmtCompletion be the result of evaluating Statement.
2. Return Completion(UpdateEmpty(stmtCompletion, undefined)).

13.7迭代语句

Syntax

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

while

(

[+In, ?Yield, ?Await]

)

;

while

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[~In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

var

[~In, ?Yield, ?Await]

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

[~In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

Note

This section is extended by Annex B.3.6.

13.7.1语义

13.7.1.1静态语义: 早期错误

while

(

)

;

while

(

)

for

(

opt

;

opt

;

opt

)

for

(

var

;

opt

;

opt

)

for

(

opt

;

opt

)

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

这是一个句法错误如果 IsLabelledFunction(Statement) is true.

Note

It is only necessary to apply this rule if the extension specified in B.3.2 is implemented.

13.7.1.2运行时语义: LoopContinues ( `completion`, `labelSet` )

The 抽象操作 LoopContinues with arguments completion and labelSet is defined by the following steps:

If completion.[[Type]] is normal, return true.
If completion.[[Type]] is not continue, return false.
If completion.[[Target]] is empty, return true.
If completion.[[Target]] is an element of labelSet, return true.
Return false.

Note

Within the Statement part of an IterationStatement a ContinueStatement may be used to begin a new iteration.

13.7.2The `do`-`while` Statement

13.7.2.1静态语义: ContainsDuplicateLabels

With parameter labelSet.

while

(

)

;

Return ContainsDuplicateLabels of Statement with argument labelSet.

13.7.2.2静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

while

(

)

;

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

13.7.2.3静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

while

(

)

;

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

13.7.2.4静态语义: VarDeclaredNames

while

(

)

;

Return the VarDeclaredNames of Statement.

13.7.2.5静态语义: VarScopedDeclarations

while

(

)

;

Return the VarScopedDeclarations of Statement.

13.7.2.6运行时语义: LabelledEvaluation

With parameter labelSet.

while

(

)

;

Let V be undefined.
Repeat,
1. Let stmtResult be the result of evaluating Statement.
2. If LoopContinues(stmtResult, labelSet) is false, return Completion(UpdateEmpty(stmtResult, V)).
3. If stmtResult.[[Value]] is not empty, set V to stmtResult.[[Value]].
4. Let exprRef be the result of evaluating Expression.
5. Let exprValue be ? GetValue(exprRef).
6. If ToBoolean(exprValue) is false, return NormalCompletion(V).

13.7.3The `while` Statement

13.7.3.1静态语义: ContainsDuplicateLabels

With parameter labelSet.

while

(

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

13.7.3.2静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

while

(

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

13.7.3.3静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

while

(

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

13.7.3.4静态语义: VarDeclaredNames

while

(

)

Return the VarDeclaredNames of Statement.

13.7.3.5静态语义: VarScopedDeclarations

while

(

)

Return the VarScopedDeclarations of Statement.

13.7.3.6运行时语义: LabelledEvaluation

With parameter labelSet.

while

(

)

Let V be undefined.
Repeat,
1. Let exprRef be the result of evaluating Expression.
2. Let exprValue be ? GetValue(exprRef).
3. If ToBoolean(exprValue) is false, return NormalCompletion(V).
4. Let stmtResult be the result of evaluating Statement.
5. If LoopContinues(stmtResult, labelSet) is false, return Completion(UpdateEmpty(stmtResult, V)).
6. If stmtResult.[[Value]] is not empty, set V to stmtResult.[[Value]].

13.7.4The `for` Statement

13.7.4.1静态语义: 早期错误

for

(

opt

;

opt

)

这是一个句法错误如果 any element of the 绑定名 of LexicalDeclaration also occurs in the VarDeclaredNames of Statement.

13.7.4.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

for

(

opt

;

opt

;

opt

)

for

(

var

;

opt

;

opt

)

for

(

opt

;

opt

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

13.7.4.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

for

(

opt

;

opt

;

opt

)

for

(

var

;

opt

;

opt

)

for

(

opt

;

opt

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

13.7.4.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

for

(

opt

;

opt

;

opt

)

for

(

var

;

opt

;

opt

)

for

(

opt

;

opt

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

13.7.4.5静态语义: VarDeclaredNames

for

(

opt

;

opt

;

opt

)

Return the VarDeclaredNames of Statement.

for

(

var

;

opt

;

opt

)

Let names be 绑定名 of VariableDeclarationList.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

for

(

opt

;

opt

)

Return the VarDeclaredNames of Statement.

13.7.4.6静态语义: VarScopedDeclarations

for

(

opt

;

opt

;

opt

)

Return the VarScopedDeclarations of Statement.

for

(

var

;

opt

;

opt

)

Let declarations be VarScopedDeclarations of VariableDeclarationList.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

for

(

opt

;

opt

)

Return the VarScopedDeclarations of Statement.

13.7.4.7运行时语义: LabelledEvaluation

With parameter labelSet.

for

(

opt

;

opt

;

opt

)

If the first Expression is present, then
1. Let exprRef be the result of evaluating the first Expression.
2. Perform ? GetValue(exprRef).
Return ? ForBodyEvaluation(the second Expression, the third Expression, Statement, « », labelSet).

for

(

var

;

opt

;

opt

)

Let varDcl be the result of evaluating VariableDeclarationList.
ReturnIfAbrupt(varDcl).
Return ? ForBodyEvaluation(the first Expression, the second Expression, Statement, « », labelSet).

for

(

opt

;

opt

)

Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let loopEnv be NewDeclarativeEnvironment(oldEnv).
Let loopEnvRec be loopEnv's EnvironmentRecord.
Let isConst be the result of performing IsConstantDeclaration of LexicalDeclaration.
Let 绑定名 be the 绑定名 of LexicalDeclaration.
For each element dn of 绑定名, do
1. If isConst is true, then
  1. Perform ! loopEnvRec.CreateImmutableBinding(dn, true).
2. Else,
  1. Perform ! loopEnvRec.CreateMutableBinding(dn, false).
Set the 运行时执行上下文's LexicalEnvironment to loopEnv.
Let forDcl be the result of evaluating LexicalDeclaration.
If forDcl is an abrupt completion, then
1. Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
2. Return Completion(forDcl).
If isConst is false, let perIterationLets be 绑定名; otherwise let perIterationLets be « ».
Let bodyResult be ForBodyEvaluation(the first Expression, the second Expression, Statement, perIterationLets, labelSet).
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Return Completion(bodyResult).

13.7.4.8运行时语义: ForBodyEvaluation( `test`, `increment`, `stmt`, `perIterationBindings`, `labelSet` )

The 抽象操作 ForBodyEvaluation with arguments test, increment, stmt, perIterationBindings, and labelSet is performed as follows:

Let V be undefined.
Perform ? CreatePerIterationEnvironment(perIterationBindings).
Repeat,
1. If test is not [empty], then
  1. Let testRef be the result of evaluating test.
  2. Let testValue be ? GetValue(testRef).
  3. If ToBoolean(testValue) is false, return NormalCompletion(V).
2. Let result be the result of evaluating stmt.
3. If LoopContinues(result, labelSet) is false, return Completion(UpdateEmpty(result, V)).
4. If result.[[Value]] is not empty, set V to result.[[Value]].
5. Perform ? CreatePerIterationEnvironment(perIterationBindings).
6. If increment is not [empty], then
  1. Let incRef be the result of evaluating increment.
  2. Perform ? GetValue(incRef).

13.7.4.9运行时语义: CreatePerIterationEnvironment( `perIterationBindings` )

The 抽象操作 CreatePerIterationEnvironment with argument perIterationBindings is performed as follows:

If perIterationBindings has any elements, then
1. Let lastIterationEnv be the 运行时执行上下文's LexicalEnvironment.
2. Let lastIterationEnvRec be lastIterationEnv's EnvironmentRecord.
3. Let outer be lastIterationEnv's outer environment reference.
4. Assert: outer is not null.
5. Let thisIterationEnv be NewDeclarativeEnvironment(outer).
6. Let thisIterationEnvRec be thisIterationEnv's EnvironmentRecord.
7. For each element bn of perIterationBindings, do
  1. Perform ! thisIterationEnvRec.CreateMutableBinding(bn, false).
  2. Let lastValue be ? lastIterationEnvRec.GetBindingValue(bn, true).
  3. Perform thisIterationEnvRec.InitializeBinding(bn, lastValue).
8. Set the 运行时执行上下文's LexicalEnvironment to thisIterationEnv.
Return undefined.

13.7.5The `for`-`in`, `for`-`of`, and `for`-`await`-`of` Statements

13.7.5.1静态语义: 早期错误

for

(

)

for

(

)

for

await

(

)

这是一个句法错误如果 LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if LeftHandSideExpression is not covering an AssignmentPattern.

If LeftHandSideExpression is either an ObjectLiteral or an ArrayLiteral and if LeftHandSideExpression is covering an AssignmentPattern then the following rules are not applied. Instead, the 早期错误 rules for AssignmentPattern are used.

这是一个句法错误如果 IsValidSimpleAssignmentTarget of LeftHandSideExpression is false.
这是一个句法错误如果 the LeftHandSideExpression is CoverParenthesizedExpressionAndArrowParameterList:(Expression) and Expression derives a phrase that would produce a Syntax Error according to these rules if that phrase were substituted for LeftHandSideExpression. This rule is recursively applied.

Note

The last rule means that the other rules are applied even if parentheses surround Expression.

for

(

)

for

(

)

for

await

(

)

这是一个句法错误如果 the 绑定名 of ForDeclaration contains "let".
这是一个句法错误如果 any element of the 绑定名 of ForDeclaration also occurs in the VarDeclaredNames of Statement.
这是一个句法错误如果 the 绑定名 of ForDeclaration contains any duplicate entries.

13.7.5.2静态语义: 绑定名

Return the 绑定名 of ForBinding.

13.7.5.3静态语义: ContainsDuplicateLabels

With parameter labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

Note

This section is extended by Annex B.3.6.

13.7.5.4静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

Note

This section is extended by Annex B.3.6.

13.7.5.5静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

for

(

)

for

(

var

)

for

(

)

for

(

)

for

(

var

)

for

(

)

for

await

(

)

for

await

(

var

)

for

await

(

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

Note

This section is extended by Annex B.3.6.

13.7.5.6静态语义: 是解构

Return 是解构 of ForBinding.

Return false.

Return true.

Note

This section is extended by Annex B.3.6.

13.7.5.7静态语义: VarDeclaredNames

for

(

)

Return the VarDeclaredNames of Statement.

for

(

var

)

Let names be the 绑定名 of ForBinding.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

for

(

)

Return the VarDeclaredNames of Statement.

for

(

)

for

await

(

)

Return the VarDeclaredNames of Statement.

for

(

var

)

for

await

(

var

)

Let names be the 绑定名 of ForBinding.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

for

(

)

for

await

(

)

Return the VarDeclaredNames of Statement.

Note

This section is extended by Annex B.3.6.

13.7.5.8静态语义: VarScopedDeclarations

for

(

)

Return the VarScopedDeclarations of Statement.

for

(

var

)

Let declarations be a List containing ForBinding.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

for

(

)

for

await

(

)

Return the VarScopedDeclarations of Statement.

for

(

)

for

await

(

var

)

Return the VarScopedDeclarations of Statement.

for

(

var

)

for

await

(

var

)

Let declarations be a List containing ForBinding.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

for

(

)

for

await

(

)

Return the VarScopedDeclarations of Statement.

Note

This section is extended by Annex B.3.6.

13.7.5.9运行时语义: 绑定初始化

With parameters value and environment.

Note

undefined is passed for environment to indicate that a PutValue operation should be used to assign the initialization value. This is the case for var statements and the formal parameter lists of some non-strict functions (see 9.2.13). In those cases a lexical binding is hoisted and preinitialized prior to 估值 of its 初始化器.

Return the result of performing 绑定初始化 for ForBinding passing value and environment as the arguments.

13.7.5.10运行时语义: BindingInstantiation

With parameter environment.

Let envRec be environment's EnvironmentRecord.
Assert: envRec is a declarative 环境记录.
For each element name of the 绑定名 of ForBinding, do
1. If IsConstantDeclaration of LetOrConst is true, then
  1. Perform ! envRec.CreateImmutableBinding(name, true).
2. Else,
  1. Perform ! envRec.CreateMutableBinding(name, false).

13.7.5.11运行时语义: LabelledEvaluation

With parameter labelSet.

for

(

)

Let keyResult be ? ForIn/OfHeadEvaluation(« », Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, enumerate, assignment, labelSet).

for

(

var

)

Let keyResult be ? ForIn/OfHeadEvaluation(« », Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, enumerate, varBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(绑定名 of ForDeclaration, Expression, enumerate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, enumerate, lexicalBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, iterate, assignment, labelSet).

for

(

var

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, iterate, varBinding, labelSet).

for

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(绑定名 of ForDeclaration, AssignmentExpression, iterate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, iterate, lexicalBinding, labelSet).

for

await

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(LeftHandSideExpression, Statement, keyResult, iterate, assignment, labelSet, async).

for

await

(

var

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(« », AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(ForBinding, Statement, keyResult, iterate, varBinding, labelSet, async).

for

await

(

)

Let keyResult be the result of performing ? ForIn/OfHeadEvaluation(绑定名 of ForDeclaration, AssignmentExpression, async-iterate).
Return ? ForIn/OfBodyEvaluation(ForDeclaration, Statement, keyResult, iterate, lexicalBinding, labelSet, async).

Note

This section is extended by Annex B.3.6.

13.7.5.12运行时语义: ForIn/OfHeadEvaluation ( `TDZnames`, `expr`, `iterationKind` )

The 抽象操作 ForIn/OfHeadEvaluation is called with arguments TDZnames, expr, and iterationKind. The value of iterationKind is either enumerate, iterate, or async-iterate.

Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
If TDZnames is not an empty List, then
1. Assert: TDZnames has no duplicate entries.
2. Let TDZ be NewDeclarativeEnvironment(oldEnv).
3. Let TDZEnvRec be TDZ's EnvironmentRecord.
4. For each string name in TDZnames, do
  1. Perform ! TDZEnvRec.CreateMutableBinding(name, false).
5. Set the 运行时执行上下文's LexicalEnvironment to TDZ.
Let exprRef be the result of evaluating expr.
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Let exprValue be ? GetValue(exprRef).
If iterationKind is enumerate, then
1. If exprValue is undefined or null, then
  1. Return Completion{[[Type]]: break, [[Value]]: empty, [[Target]]: empty}.
2. Let obj be ! ToObject(exprValue).
3. Return ? EnumerateObjectProperties(obj).
Else,
1. Assert: iterationKind is iterate.
2. If iterationKind is async-iterate, let iteratorHint be async.
3. Else, let iteratorHint be sync.
4. Return ? GetIterator(exprValue, iteratorHint).

13.7.5.13运行时语义: ForIn/OfBodyEvaluation ( `lhs`, `stmt`, `iteratorRecord`, `iterationKind`, `lhsKind`, `labelSet` [ , `iteratorKind` ])

The 抽象操作 ForIn/OfBodyEvaluation is called with arguments lhs, stmt, iteratorRecord, iterationKind, lhsKind, labelSet, and 可选参数 iteratorKind. The value of lhsKind is either assignment, varBinding or lexicalBinding. The value of iteratorKind is either sync or async.

If iteratorKind is not present, set iteratorKind to sync.
Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let V be undefined.
Let destructuring be 是解构 of lhs.
If destructuring is true and if lhsKind is assignment, then
1. Assert: lhs is a LeftHandSideExpression.
2. Let assignmentPattern be the AssignmentPattern that is covered by lhs.
Repeat,
1. Let nextResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[迭代器]], « »).
2. If iteratorKind is async, then set nextResult to ? Await(nextResult).
3. If Type(nextResult) is not Object, 抛出一个 TypeError 异常.
4. Let nextValue be ? IteratorValue(nextResult).
5. If lhsKind is either assignment or varBinding, then
  1. If destructuring is false, then
    1. Let lhsRef be the result of evaluating lhs. (It may be evaluated repeatedly.)
6. Else,
  1. Assert: lhsKind is lexicalBinding.
  2. Assert: lhs is a ForDeclaration.
  3. Let iterationEnv be NewDeclarativeEnvironment(oldEnv).
  4. Perform BindingInstantiation for lhs passing iterationEnv as the argument.
  5. Set the 运行时执行上下文's LexicalEnvironment to iterationEnv.
  6. If destructuring is false, then
    1. Assert: lhs binds a single name.
    2. Let lhsName be the sole element of 绑定名 of lhs.
    3. Let lhsRef be ! ResolveBinding(lhsName).
7. If destructuring is false, then
  1. If lhsRef is an abrupt completion, then
    1. Let status be lhsRef.
  2. Else if lhsKind is lexicalBinding, then
    1. Let status be InitializeReferencedBinding(lhsRef, nextValue).
  3. Else,
    1. Let status be PutValue(lhsRef, nextValue).
8. Else,
  1. If lhsKind is assignment, then
    1. Let status be the result of performing DestructuringAssignmentEvaluation of assignmentPattern using nextValue as the argument.
  2. Else if lhsKind is varBinding, then
    1. Assert: lhs is a ForBinding.
    2. Let status be the result of performing 绑定初始化 for lhs passing nextValue and undefined as the arguments.
  3. Else,
    1. Assert: lhsKind is lexicalBinding.
    2. Assert: lhs is a ForDeclaration.
    3. Let status be the result of performing 绑定初始化 for lhs passing nextValue and iterationEnv as arguments.
9. If status is an abrupt completion, then
  1. Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
  2. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
  3. If iterationKind is enumerate, then
    1. Return status.
  4. Else,
    1. Assert: iterationKind is iterate.
    2. Return ? IteratorClose(iteratorRecord, status).
10. Let result be the result of evaluating stmt.
11. Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
12. If LoopContinues(result, labelSet) is false, then
  1. If iterationKind is enumerate, then
    1. Return Completion(UpdateEmpty(result, V)).
  2. Else,
    1. Assert: iterationKind is iterate.
    2. Set status to UpdateEmpty(result, V).
    3. If iteratorKind is async, return ? AsyncIteratorClose(iteratorRecord, status).
    4. Return ? IteratorClose(iteratorRecord, status).
13. If result.[[Value]] is not empty, set V to result.[[Value]].

13.7.5.14运行时语义: 估值

Let bindingId be 字符值 of BindingIdentifier.
Return ? ResolveBinding(bindingId).

13.7.5.15EnumerateObjectProperties ( `O` )

When the 抽象操作 EnumerateObjectProperties is called with argument O, 执行如下:

Assert: Type(O) is Object.
Return an 迭代器 object (25.1.1.2) whose next method iterates over all the String-valued keys of enumerable properties of O. The 迭代器 object is never directly accessible to ES 代码. The mechanics and order of enumerating the properties is not specified but must conform to the rules specified below.

The 迭代器's throw and return methods are null and are never invoked. The 迭代器's next method processes object properties to determine whether the property key should be returned as an 迭代器 value. Returned 属性键 do not include keys that are Symbols. Properties of the target object may be deleted during enumeration. A property that is deleted before it is processed by the 迭代器's next method is ignored. If new properties are added to the target object during enumeration, the newly added properties are not guaranteed to be processed in the active enumeration. A 属性名 will be returned by the 迭代器's next method at most once in any enumeration.

Enumerating the properties of the target object includes enumerating properties of its prototype, and the prototype of the prototype, and so on, recursively; but a property of a prototype is not processed if it has the same name as a property that has already been processed by the 迭代器's next method. The values of [[Enumerable]] 特性 are not considered when determining if a property of a 原型对象 has already been processed. The enumerable property names of prototype objects must be obtained by invoking EnumerateObjectProperties passing the 原型对象 as the argument. EnumerateObjectProperties must obtain the 自身属性 keys of the target object by calling its [[OwnPropertyKeys]] 内部方法. 属性特性 of the target object must be obtained by calling its [[GetOwnProperty]] 内部方法.

Note

The following is an informative definition of an ES 生成器函数 that conforms to these rules:

function* EnumerateObjectProperties(obj) {
                      const visited = new Set();
                      for (const key of Reflect.ownKeys(obj)) {
                      if (typeof key === "symbol") continue;
                      const desc = Reflect.getOwnPropertyDescriptor(obj, key);
                      if (desc) {
                      visited.add(key);
                      if (desc.enumerable) yield key;
                    }
                  }
                  const proto = Reflect.getPrototypeOf(obj);
                  if (proto === null) return;
                  for (const protoKey of EnumerateObjectProperties(proto)) {
                  if (!visited.has(protoKey)) yield protoKey;
                }
              }

13.8`continue` 语句

Syntax

[Yield, Await]

continue

;

continue

[no LineTerminator here]

[?Yield, ?Await]

;

13.8.1静态语义: 早期错误

continue

;

continue

;

这是一个句法错误如果 this ContinueStatement is not nested, directly or indirectly (but not crossing function boundaries), within an IterationStatement.

13.8.2静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

continue

;

Return false.

continue

;

If the 字符值 of LabelIdentifier is not an element of iterationSet, return true.
Return false.

13.8.3运行时语义: 估值

continue

;

Return Completion{[[Type]]: continue, [[Value]]: empty, [[Target]]: empty}.

continue

;

Let label be the 字符值 of LabelIdentifier.
Return Completion{[[Type]]: continue, [[Value]]: empty, [[Target]]: label }.

13.9`break` 语句

Syntax

[Yield, Await]

break

;

break

[no LineTerminator here]

[?Yield, ?Await]

;

13.9.1静态语义: 早期错误

break

;

这是一个句法错误如果 this BreakStatement is not nested, directly or indirectly (but not crossing function boundaries), within an IterationStatement or a SwitchStatement.

13.9.2静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

break

;

Return false.

break

;

If the 字符值 of LabelIdentifier is not an element of labelSet, return true.
Return false.

13.9.3运行时语义: 估值

break

;

Return Completion{[[Type]]: break, [[Value]]: empty, [[Target]]: empty}.

break

;

Let label be the 字符值 of LabelIdentifier.
Return Completion{[[Type]]: break, [[Value]]: empty, [[Target]]: label }.

13.10`return` 语句

Syntax

[Yield, Await]

return

;

return

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

Note

A return statement causes a function to cease execution and, in most cases, returns a value to the caller. If Expression is omitted, the 返回值 is undefined. Otherwise, the 返回值 is the value of Expression. A return statement may not actually return a value to the caller depending on surrounding context. 例如, in a try block, a return statement's 完成记录 may be replaced with another 完成记录 during 估值 of the finally block.

13.10.1运行时语义: 估值

return

;

Return Completion{[[Type]]: return, [[Value]]: undefined, [[Target]]: empty}.

return

;

Let exprRef be the result of evaluating Expression.
Let exprValue be ? GetValue(exprRef).
If ! GetGeneratorKind() is async, set exprValue to ? Await(exprValue).
Return Completion{[[Type]]: return, [[Value]]: exprValue, [[Target]]: empty}.

13.11`with` 语句

Syntax

[Yield, Await, Return]

with

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

Note

with 语句 adds an object 环境记录 for a computed object to the 词法环境 of the 运行时执行上下文. It then executes a statement using this augmented 词法环境. Finally, it restores the original 词法环境.

13.11.1静态语义: 早期错误

with

(

)

这是一个句法错误如果 the code that matches this production is contained in 严格模式代码.
这是一个句法错误如果 IsLabelledFunction(Statement) is true.

Note

It is only necessary to apply the second rule if the extension specified in B.3.2 is implemented.

13.11.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

with

(

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

13.11.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

with

(

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

13.11.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

with

(

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

13.11.5静态语义: VarDeclaredNames

with

(

)

Return the VarDeclaredNames of Statement.

13.11.6静态语义: VarScopedDeclarations

with

(

)

Return the VarScopedDeclarations of Statement.

13.11.7运行时语义: 估值

with

(

)

Let val be the result of evaluating Expression.
Let obj be ? ToObject(? GetValue(val)).
Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let newEnv be NewObjectEnvironment(obj, oldEnv).
Set the withEnvironment flag of newEnv's EnvironmentRecord to true.
Set the 运行时执行上下文's LexicalEnvironment to newEnv.
Let C be the result of evaluating Statement.
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Return Completion(UpdateEmpty(C, undefined)).

Note

No matter how control leaves the embedded Statement, whether normally or by some form of abrupt completion or 异常, the LexicalEnvironment is always restored to its former state.

13.12`switch` 语句

Syntax

[Yield, Await, Return]

switch

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

{

[?Yield, ?Await, ?Return]

opt

}

{

[?Yield, ?Await, ?Return]

opt

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

opt

}

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

case

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Return]

opt

[Yield, Await, Return]

default

[?Yield, ?Await, ?Return]

opt

13.12.1静态语义: 早期错误

switch

(

)

这是一个句法错误如果 the LexicallyDeclaredNames of CaseBlock contains any duplicate entries.
这是一个句法错误如果 any element of the LexicallyDeclaredNames of CaseBlock also occurs in the VarDeclaredNames of CaseBlock.

13.12.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

switch

(

)

Return ContainsDuplicateLabels of CaseBlock with argument labelSet.

{

}

Return false.

{

opt

opt

}

If the first CaseClauses is present, then
1. Let hasDuplicates be ContainsDuplicateLabels of the first CaseClauses with argument labelSet.
2. If hasDuplicates is true, return true.
Let hasDuplicates be ContainsDuplicateLabels of DefaultClause with argument labelSet.
If hasDuplicates is true, return true.
If the second CaseClauses is not present, return false.
Return ContainsDuplicateLabels of the second CaseClauses with argument labelSet.

Let hasDuplicates be ContainsDuplicateLabels of CaseClauses with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of CaseClause with argument labelSet.

case

opt

If the StatementList is present, return ContainsDuplicateLabels of StatementList with argument labelSet.
Return false.

default

opt

If the StatementList is present, return ContainsDuplicateLabels of StatementList with argument labelSet.
Return false.

13.12.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

switch

(

)

Return ContainsUndefinedBreakTarget of CaseBlock with argument labelSet.

{

}

Return false.

{

opt

opt

}

If the first CaseClauses is present, then
1. Let hasUndefinedLabels be ContainsUndefinedBreakTarget of the first CaseClauses with argument labelSet.
2. If hasUndefinedLabels is true, return true.
Let hasUndefinedLabels be ContainsUndefinedBreakTarget of DefaultClause with argument labelSet.
If hasUndefinedLabels is true, return true.
If the second CaseClauses is not present, return false.
Return ContainsUndefinedBreakTarget of the second CaseClauses with argument labelSet.

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of CaseClauses with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of CaseClause with argument labelSet.

case

opt

If the StatementList is present, return ContainsUndefinedBreakTarget of StatementList with argument labelSet.
Return false.

default

opt

If the StatementList is present, return ContainsUndefinedBreakTarget of StatementList with argument labelSet.
Return false.

13.12.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

switch

(

)

Return ContainsUndefinedContinueTarget of CaseBlock with arguments iterationSet and « ».

{

}

Return false.

{

opt

opt

}

If the first CaseClauses is present, then
1. Let hasUndefinedLabels be ContainsUndefinedContinueTarget of the first CaseClauses with arguments iterationSet and « ».
2. If hasUndefinedLabels is true, return true.
Let hasUndefinedLabels be ContainsUndefinedContinueTarget of DefaultClause with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
If the second CaseClauses is not present, return false.
Return ContainsUndefinedContinueTarget of the second CaseClauses with arguments iterationSet and « ».

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of CaseClauses with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of CaseClause with arguments iterationSet and « ».

case

opt

If the StatementList is present, return ContainsUndefinedContinueTarget of StatementList with arguments iterationSet and « ».
Return false.

default

opt

If the StatementList is present, return ContainsUndefinedContinueTarget of StatementList with arguments iterationSet and « ».
Return false.

13.12.5静态语义: LexicallyDeclaredNames

{

}

Return a new empty List.

{

opt

opt

}

If the first CaseClauses is present, let names be the LexicallyDeclaredNames of the first CaseClauses.
Else, let names be a new empty List.
Append to names the elements of the LexicallyDeclaredNames of the DefaultClause.
If the second CaseClauses is not present, return names.
Return the result of appending to names the elements of the LexicallyDeclaredNames of the second CaseClauses.

Let names be LexicallyDeclaredNames of CaseClauses.
Append to names the elements of the LexicallyDeclaredNames of CaseClause.
Return names.

case

opt

If the StatementList is present, return the LexicallyDeclaredNames of StatementList.
Return a new empty List.

default

opt

If the StatementList is present, return the LexicallyDeclaredNames of StatementList.
Return a new empty List.

13.12.6静态语义: LexicallyScopedDeclarations

{

}

Return a new empty List.

{

opt

opt

}

If the first CaseClauses is present, let declarations be the LexicallyScopedDeclarations of the first CaseClauses.
Else, let declarations be a new empty List.
Append to declarations the elements of the LexicallyScopedDeclarations of the DefaultClause.
If the second CaseClauses is not present, return declarations.
Return the result of appending to declarations the elements of the LexicallyScopedDeclarations of the second CaseClauses.

Let declarations be LexicallyScopedDeclarations of CaseClauses.
Append to declarations the elements of the LexicallyScopedDeclarations of CaseClause.
Return declarations.

case

opt

If the StatementList is present, return the LexicallyScopedDeclarations of StatementList.
Return a new empty List.

default

opt

If the StatementList is present, return the LexicallyScopedDeclarations of StatementList.
Return a new empty List.

13.12.7静态语义: VarDeclaredNames

switch

(

)

Return the VarDeclaredNames of CaseBlock.

{

}

Return a new empty List.

{

opt

opt

}

If the first CaseClauses is present, let names be the VarDeclaredNames of the first CaseClauses.
Else, let names be a new empty List.
Append to names the elements of the VarDeclaredNames of the DefaultClause.
If the second CaseClauses is not present, return names.
Return the result of appending to names the elements of the VarDeclaredNames of the second CaseClauses.

Let names be VarDeclaredNames of CaseClauses.
Append to names the elements of the VarDeclaredNames of CaseClause.
Return names.

case

opt

If the StatementList is present, return the VarDeclaredNames of StatementList.
Return a new empty List.

default

opt

If the StatementList is present, return the VarDeclaredNames of StatementList.
Return a new empty List.

13.12.8静态语义: VarScopedDeclarations

switch

(

)

Return the VarScopedDeclarations of CaseBlock.

{

}

Return a new empty List.

{

opt

opt

}

If the first CaseClauses is present, let declarations be the VarScopedDeclarations of the first CaseClauses.
Else, let declarations be a new empty List.
Append to declarations the elements of the VarScopedDeclarations of the DefaultClause.
If the second CaseClauses is not present, return declarations.
Return the result of appending to declarations the elements of the VarScopedDeclarations of the second CaseClauses.

Let declarations be VarScopedDeclarations of CaseClauses.
Append to declarations the elements of the VarScopedDeclarations of CaseClause.
Return declarations.

case

opt

If the StatementList is present, return the VarScopedDeclarations of StatementList.
Return a new empty List.

default

opt

If the StatementList is present, return the VarScopedDeclarations of StatementList.
Return a new empty List.

13.12.9运行时语义: CaseBlockEvaluation

With parameter input.

{

}

Return NormalCompletion(undefined).

{

}

Let V be undefined.
Let A be the List of CaseClause items in CaseClauses, in 源文本 order.
Let found be false.
For each CaseClause C in A, do
1. If found is false, then
  1. Set found to ? CaseClauseIsSelected(C, input).
2. If found is true, then
  1. Let R be the result of evaluating C.
  2. If R.[[Value]] is not empty, set V to R.[[Value]].
  3. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
Return NormalCompletion(V).

{

opt

opt

}

Let V be undefined.
If the first CaseClauses is present, then
1. Let A be the List of CaseClause items in the first CaseClauses, in 源文本 order.
Else,
1. Let A be « ».
Let found be false.
For each CaseClause C in A, do
1. If found is false, then
  1. Set found to ? CaseClauseIsSelected(C, input).
2. If found is true, then
  1. Let R be the result of evaluating C.
  2. If R.[[Value]] is not empty, set V to R.[[Value]].
  3. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
Let foundInB be false.
If the second CaseClauses is present, then
1. Let B be the List of CaseClause items in the second CaseClauses, in 源文本 order.
Else,
1. Let B be « ».
If found is false, then
1. For each CaseClause C in B, do
  1. If foundInB is false, then
    1. Set foundInB to ? CaseClauseIsSelected(C, input).
  2. If foundInB is true, then
    1. Let R be the result of evaluating CaseClause C.
    2. If R.[[Value]] is not empty, set V to R.[[Value]].
    3. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
If foundInB is true, return NormalCompletion(V).
Let R be the result of evaluating DefaultClause.
If R.[[Value]] is not empty, set V to R.[[Value]].
If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
For each CaseClause C in B (NOTE: this is another complete iteration of the second CaseClauses), do
1. Let R be the result of evaluating CaseClause C.
2. If R.[[Value]] is not empty, set V to R.[[Value]].
3. If R is an abrupt completion, return Completion(UpdateEmpty(R, V)).
Return NormalCompletion(V).

13.12.10运行时语义: CaseClauseIsSelected ( `C`, `input` )

The 抽象操作 CaseClauseIsSelected, given CaseClause C and value input, determines whether C matches input.

Assert: C is an instance of the production CaseClause:caseExpression:StatementListopt .
Let exprRef be the result of evaluating the Expression of C.
Let clauseSelector be ? GetValue(exprRef).
Return the result of performing 严格相等比较 input === clauseSelector.

Note

This operation does not execute C's StatementList (if any). The CaseBlock 算法 uses its 返回值 to determine which StatementList to start executing.

13.12.11运行时语义: 估值

switch

(

)

Let exprRef be the result of evaluating Expression.
Let switchValue be ? GetValue(exprRef).
Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let blockEnv be NewDeclarativeEnvironment(oldEnv).
Perform BlockDeclarationInstantiation(CaseBlock, blockEnv).
Set the 运行时执行上下文's LexicalEnvironment to blockEnv.
Let R be the result of performing CaseBlockEvaluation of CaseBlock with argument switchValue.
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Return R.

Note

No matter how control leaves the SwitchStatement the LexicalEnvironment is always restored to its former state.

case

Return NormalCompletion(empty).

case

Return the result of evaluating StatementList.

default

Return NormalCompletion(empty).

default

Return the result of evaluating StatementList.

13.13标签语句

Syntax

[Yield, Await, Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ~Default]

Note

A Statement may be prefixed by a label. 标签语句 are only used in conjunction with labelled break and continue statements. ES has no goto statement. A Statement can be part of a LabelledStatement, which itself can be part of a LabelledStatement, and so on. The labels introduced this way are collectively referred to as the “current label set” when describing the 语义 of individual statements.

13.13.1静态语义: 早期错误

这是一个句法错误如果 any 源文本 matches this rule.

Note

An alternative definition for this rule is provided in B.3.2.

13.13.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

Let label be the 字符值 of LabelIdentifier.
If label is an element of labelSet, return true.
Let newLabelSet be a copy of labelSet with label appended.
Return ContainsDuplicateLabels of LabelledItem with argument newLabelSet.

Return false.

13.13.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

Let label be the 字符值 of LabelIdentifier.
Let newLabelSet be a copy of labelSet with label appended.
Return ContainsUndefinedBreakTarget of LabelledItem with argument newLabelSet.

Return false.

13.13.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

Let label be the 字符值 of LabelIdentifier.
Let newLabelSet be a copy of labelSet with label appended.
Return ContainsUndefinedContinueTarget of LabelledItem with arguments iterationSet and newLabelSet.

Return false.

13.13.5静态语义: IsLabelledFunction ( `stmt` )

The 抽象操作 IsLabelledFunction with argument stmt 执行如下:

If stmt is not a LabelledStatement, return false.
Let item be the LabelledItem of stmt.
If item is LabelledItem:FunctionDeclaration , return true.
Let subStmt be the Statement of item.
Return IsLabelledFunction(subStmt).

13.13.6静态语义: LexicallyDeclaredNames

Return the LexicallyDeclaredNames of LabelledItem.

Return a new empty List.

Return 绑定名 of FunctionDeclaration.

13.13.7静态语义: LexicallyScopedDeclarations

Return the LexicallyScopedDeclarations of LabelledItem.

Return a new empty List.

Return a new List containing FunctionDeclaration.

13.13.8静态语义: TopLevelLexicallyDeclaredNames

Return a new empty List.

13.13.9静态语义: TopLevelLexicallyScopedDeclarations

Return a new empty List.

13.13.10静态语义: TopLevelVarDeclaredNames

Return the TopLevelVarDeclaredNames of LabelledItem.

If Statement is Statement:LabelledStatement , return TopLevelVarDeclaredNames of Statement.
Return VarDeclaredNames of Statement.

Return 绑定名 of FunctionDeclaration.

13.13.11静态语义: TopLevelVarScopedDeclarations

Return the TopLevelVarScopedDeclarations of LabelledItem.

If Statement is Statement:LabelledStatement , return TopLevelVarScopedDeclarations of Statement.
Return VarScopedDeclarations of Statement.

Return a new List containing FunctionDeclaration.

13.13.12静态语义: VarDeclaredNames

Return the VarDeclaredNames of LabelledItem.

Return a new empty List.

13.13.13静态语义: VarScopedDeclarations

Return the VarScopedDeclarations of LabelledItem.

Return a new empty List.

13.13.14运行时语义: LabelledEvaluation

With parameter labelSet.

Let label be the 字符值 of LabelIdentifier.
Append label as an element of labelSet.
Let stmtResult be LabelledEvaluation of LabelledItem with argument labelSet.
If stmtResult.[[Type]] is break and SameValue(stmtResult.[[Target]], label) is true, then
1. Set stmtResult to NormalCompletion(stmtResult.[[Value]]).
Return Completion(stmtResult).

If Statement is either a LabelledStatement or a BreakableStatement, then
1. Return LabelledEvaluation of Statement with argument labelSet.
Else,
1. Return the result of evaluating Statement.

Return the result of evaluating FunctionDeclaration.

13.13.15运行时语义: 估值

Let newLabelSet be a new empty List.
Return LabelledEvaluation of this LabelledStatement with argument newLabelSet.

13.14`throw` 语句

Syntax

[Yield, Await]

throw

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

13.14.1运行时语义: 估值

throw

;

Let exprRef be the result of evaluating Expression.
Let exprValue be ? GetValue(exprRef).
Return Completion{[[Type]]: throw, [[Value]]: exprValue, [[Target]]: empty}.

13.15`try` 语句

Syntax

[Yield, Await, Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

catch

(

[?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

finally

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

Note

try 语句 encloses a block of code in which an exceptional condition can occur, 例如 a runtime error or a throw statement. The catch clause provides the 异常-handling code. When a catch clause catches an 异常, its CatchParameter is bound to that 异常.

13.15.1静态语义: 早期错误

catch

(

)

这是一个句法错误如果绑定名 of CatchParameter contains any duplicate elements.
这是一个句法错误如果 any element of the 绑定名 of CatchParameter also occurs in the LexicallyDeclaredNames of Block.
这是一个句法错误如果 any element of the 绑定名 of CatchParameter also occurs in the VarDeclaredNames of Block.

Note

An alternative 静态语义 for this production is given in B.3.5.

13.15.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

try

Let hasDuplicates be ContainsDuplicateLabels of Block with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of Catch with argument labelSet.

try

Let hasDuplicates be ContainsDuplicateLabels of Block with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of Finally with argument labelSet.

try

Let hasDuplicates be ContainsDuplicateLabels of Block with argument labelSet.
If hasDuplicates is true, return true.
Let hasDuplicates be ContainsDuplicateLabels of Catch with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of Finally with argument labelSet.

catch

(

)

Return ContainsDuplicateLabels of Block with argument labelSet.

13.15.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

try

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of Block with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of Catch with argument labelSet.

try

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of Block with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of Finally with argument labelSet.

try

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of Block with argument labelSet.
If hasUndefinedLabels is true, return true.
Let hasUndefinedLabels be ContainsUndefinedBreakTarget of Catch with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of Finally with argument labelSet.

catch

(

)

Return ContainsUndefinedBreakTarget of Block with argument labelSet.

13.15.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

try

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of Block with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of Catch with arguments iterationSet and « ».

try

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of Block with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of Finally with arguments iterationSet and « ».

try

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of Block with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Let hasUndefinedLabels be ContainsUndefinedContinueTarget of Catch with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of Finally with arguments iterationSet and « ».

catch

(

)

Return ContainsUndefinedContinueTarget of Block with arguments iterationSet and « ».

13.15.5静态语义: VarDeclaredNames

try

Let names be VarDeclaredNames of Block.
Append to names the elements of the VarDeclaredNames of Catch.
Return names.

try

Let names be VarDeclaredNames of Block.
Append to names the elements of the VarDeclaredNames of Finally.
Return names.

try

Let names be VarDeclaredNames of Block.
Append to names the elements of the VarDeclaredNames of Catch.
Append to names the elements of the VarDeclaredNames of Finally.
Return names.

catch

(

)

Return the VarDeclaredNames of Block.

13.15.6静态语义: VarScopedDeclarations

try

Let declarations be VarScopedDeclarations of Block.
Append to declarations the elements of the VarScopedDeclarations of Catch.
Return declarations.

try

Let declarations be VarScopedDeclarations of Block.
Append to declarations the elements of the VarScopedDeclarations of Finally.
Return declarations.

try

Let declarations be VarScopedDeclarations of Block.
Append to declarations the elements of the VarScopedDeclarations of Catch.
Append to declarations the elements of the VarScopedDeclarations of Finally.
Return declarations.

catch

(

)

Return the VarScopedDeclarations of Block.

13.15.7运行时语义: CatchClauseEvaluation

With parameter thrownValue.

catch

(

)

Let oldEnv be the 运行时执行上下文's LexicalEnvironment.
Let catchEnv be NewDeclarativeEnvironment(oldEnv).
Let catchEnvRec be catchEnv's EnvironmentRecord.
For each element argName of the 绑定名 of CatchParameter, do
1. Perform ! catchEnvRec.CreateMutableBinding(argName, false).
Set the 运行时执行上下文's LexicalEnvironment to catchEnv.
Let status be the result of performing 绑定初始化 for CatchParameter passing thrownValue and catchEnv as arguments.
If status is an abrupt completion, then
1. Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
2. Return Completion(status).
Let B be the result of evaluating Block.
Set the 运行时执行上下文's LexicalEnvironment to oldEnv.
Return Completion(B).

Note

No matter how control leaves the Block the LexicalEnvironment is always restored to its former state.

13.15.8运行时语义: 估值

try

Let B be the result of evaluating Block.
If B.[[Type]] is throw, let C be CatchClauseEvaluation of Catch with argument B.[[Value]].
Else, let C be B.
Return Completion(UpdateEmpty(C, undefined)).

try

Let B be the result of evaluating Block.
Let F be the result of evaluating Finally.
If F.[[Type]] is normal, set F to B.
Return Completion(UpdateEmpty(F, undefined)).

try

Let B be the result of evaluating Block.
If B.[[Type]] is throw, let C be CatchClauseEvaluation of Catch with argument B.[[Value]].
Else, let C be B.
Let F be the result of evaluating Finally.
If F.[[Type]] is normal, set F to C.
Return Completion(UpdateEmpty(F, undefined)).

13.16`debugger` 语句

Syntax

debugger

;

13.16.1运行时语义: 估值

Note

Evaluating a DebuggerStatement may allow an 实现 to cause a breakpoint when run under a debugger. If a debugger is not present or active this statement has no observable effect.

debugger

;

If an 实现-defined debugging facility is available and enabled, then
1. Perform an 实现-defined debugging action.
2. Let result be an 实现-defined Completion value.
Else,
1. Let result be NormalCompletion(empty).
Return result.

14ES 语言: 函数和类

Note

Various ES language elements cause the creation of ES 函数对象 (9.2). 估值 of such functions starts with the execution of their [[Call]] 内部方法 (9.2.1).

14.1函数声明

Syntax

[Yield, Await, Default]

function

[?Yield, ?Await]

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[+Default]

function

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

function

[~Yield, ~Await]

opt

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[empty]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await, +Return]

opt

14.1.1指令序言和使用严格指令

A Directive Prologue is the longest sequence of ExpressionStatements occurring as the initial StatementListItems or ModuleItems of a FunctionBody, a ScriptBody, or a ModuleBody and where each ExpressionStatement in the sequence consists entirely of a StringLiteral token followed by a semicolon. The semicolon may appear explicitly or may be inserted by 自动分号插入. A Directive Prologue may be an empty sequence.

A Use Strict Directive is an ExpressionStatement in a Directive Prologue whose StringLiteral is either the exact 代码单元 sequences "use strict" or 'use strict'. A Use Strict Directive may not contain an EscapeSequence or LineContinuation.

A Directive Prologue may contain more than one Use Strict Directive. However, an 实现 may issue a warning if this occurs.

Note

The ExpressionStatements of a Directive Prologue are evaluated normally during 估值 of the containing production. Implementations may define 实现 specific meanings for ExpressionStatements which are not a Use Strict Directive and which occur in a Directive Prologue. If an appropriate notification mechanism exists, an 实现 should issue a warning if it encounters in a Directive Prologue an ExpressionStatement that is not a Use Strict Directive and which does not have a meaning defined by the 实现.

14.1.2静态语义: 早期错误

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

If the source code matching this production is 严格模式代码, the 早期错误 rules for UniqueFormalParameters:FormalParameters are applied.
If the source code matching this production is 严格模式代码, 这是一个句法错误如果 BindingIdentifier is present and the 字符值 of BindingIdentifier is "eval" or "arguments".
这是一个句法错误如果 ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of FormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of FormalParameters also occurs in the LexicallyDeclaredNames of FunctionBody.
这是一个句法错误如果 FormalParameters Contains SuperProperty is true.
这是一个句法错误如果 FunctionBody Contains SuperProperty is true.
这是一个句法错误如果 FormalParameters Contains SuperCall is true.
这是一个句法错误如果 FunctionBody Contains SuperCall is true.

Note 1

The LexicallyDeclaredNames of a FunctionBody does not include 标识符 bound using var or 函数声明.

这是一个句法错误如果绑定名 of FormalParameters contains any duplicate elements.

这是一个句法错误如果 IsSimpleParameterList of FormalParameterList is false and 绑定名 of FormalParameterList contains any duplicate elements.

Note 2

Multiple occurrences of the same BindingIdentifier in a FormalParameterList is only allowed for functions which have simple parameter lists and which are not defined in 严格模式代码.

这是一个句法错误如果 the LexicallyDeclaredNames of FunctionStatementList contains any duplicate entries.
这是一个句法错误如果 any element of the LexicallyDeclaredNames of FunctionStatementList also occurs in the VarDeclaredNames of FunctionStatementList.
这是一个句法错误如果 ContainsDuplicateLabels of FunctionStatementList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedBreakTarget of FunctionStatementList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedContinueTarget of FunctionStatementList with arguments « » and « » is true.

14.1.3静态语义: 绑定名

function

(

)

{

}

Return the 绑定名 of BindingIdentifier.

function

(

)

{

}

Return « "*default*" ».

Note

"*default*" is used within this specification as a synthetic name for hoistable anonymous functions that are defined using export declarations.

[empty]

Return a new empty List.

Let names be 绑定名 of FormalParameterList.
Append to names the 绑定名 of FunctionRestParameter.
Return names.

Let names be 绑定名 of FormalParameterList.
Append to names the 绑定名 of FormalParameter.
Return names.

14.1.4静态语义: Contains

With parameter symbol.

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

Return false.

Note

静态语义规则 that depend upon substructure generally do not look into 函数定义.

14.1.5静态语义: ContainsExpression

[empty]

Return false.

If ContainsExpression of FormalParameterList is true, return true.
Return ContainsExpression of FunctionRestParameter.

If ContainsExpression of FormalParameterList is true, return true.
Return ContainsExpression of FormalParameter.

14.1.6静态语义: ContainsUseStrict

If the Directive Prologue of FunctionStatementList contains a Use Strict Directive, return true; otherwise, return false.

14.1.7静态语义: ExpectedArgumentCount

[empty]

Return 0.

Return ExpectedArgumentCount of FormalParameterList.

Note

The ExpectedArgumentCount of a FormalParameterList is the number of FormalParameters to the left of either the rest parameter or the first FormalParameter with an 初始化器. A FormalParameter without an 初始化器 is allowed after the first parameter with an 初始化器 but such parameters are considered to be optional with undefined as their 默认值.

Let count be ExpectedArgumentCount of FormalParameterList.
If HasInitializer of FormalParameterList is true or HasInitializer of FormalParameter is true, return count.
Return count + 1.

14.1.8静态语义: HasInitializer

If HasInitializer of FormalParameterList is true, return true.
Return HasInitializer of FormalParameter.

14.1.9静态语义: HasName

function

(

)

{

}

Return false.

function

(

)

{

}

Return true.

14.1.10静态语义: IsAnonymousFunctionDefinition ( `expr` )

The 抽象操作 IsAnonymousFunctionDefinition determines if its argument is a function definition that does not bind a name. The argument expr is the result of parsing an AssignmentExpression or 初始化器. 执行如下:

If 是函数定义 of expr is false, return false.
Let hasName be the result of HasName of expr.
If hasName is true, return false.
Return true.

14.1.11静态语义: IsConstantDeclaration

function

(

)

{

}

function

(

)

{

}

Return false.

14.1.12静态语义: 是函数定义

function

opt

(

)

{

}

Return true.

14.1.13静态语义: IsSimpleParameterList

[empty]

Return true.

Return false.

If IsSimpleParameterList of FormalParameterList is false, return false.
Return IsSimpleParameterList of FormalParameter.

Return IsSimpleParameterList of BindingElement.

14.1.14静态语义: LexicallyDeclaredNames

[empty]

Return a new empty List.

Return TopLevelLexicallyDeclaredNames of StatementList.

14.1.15静态语义: LexicallyScopedDeclarations

[empty]

Return a new empty List.

Return the TopLevelLexicallyScopedDeclarations of StatementList.

14.1.16静态语义: VarDeclaredNames

[empty]

Return a new empty List.

Return TopLevelVarDeclaredNames of StatementList.

14.1.17静态语义: VarScopedDeclarations

[empty]

Return a new empty List.

Return the TopLevelVarScopedDeclarations of StatementList.

14.1.18运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
Return the result of evaluating FunctionStatementList.

14.1.19运行时语义: IteratorBindingInitialization

With parameters iteratorRecord and environment.

Note 1

[empty]

Return NormalCompletion(empty).

Perform ? IteratorBindingInitialization for FormalParameterList using iteratorRecord and environment as the arguments.
Return the result of performing IteratorBindingInitialization for FunctionRestParameter using iteratorRecord and environment as the arguments.

Perform ? IteratorBindingInitialization for FormalParameterList using iteratorRecord and environment as the arguments.
Return the result of performing IteratorBindingInitialization for FormalParameter using iteratorRecord and environment as the arguments.

If ContainsExpression of BindingElement is false, return the result of performing IteratorBindingInitialization for BindingElement using iteratorRecord and environment as the arguments.
Let currentContext be the 运行时执行上下文.
Let originalEnv be the VariableEnvironment of currentContext.
Assert: The VariableEnvironment and LexicalEnvironment of currentContext are the same.
Assert: environment and originalEnv are the same.
Let paramVarEnv be NewDeclarativeEnvironment(originalEnv).
Set the VariableEnvironment of currentContext to paramVarEnv.
Set the LexicalEnvironment of currentContext to paramVarEnv.
Let result be the result of performing IteratorBindingInitialization for BindingElement using iteratorRecord and environment as the arguments.
Set the VariableEnvironment of currentContext to originalEnv.
Set the LexicalEnvironment of currentContext to originalEnv.
Return result.

Note 2

The new 环境记录 created in step 6 is only used if the BindingElement contains a direct eval.

If ContainsExpression of BindingRestElement is false, return the result of performing IteratorBindingInitialization for BindingRestElement using iteratorRecord and environment as the arguments.
Let currentContext be the 运行时执行上下文.
Let originalEnv be the VariableEnvironment of currentContext.
Assert: The VariableEnvironment and LexicalEnvironment of currentContext are the same.
Assert: environment and originalEnv are the same.
Let paramVarEnv be NewDeclarativeEnvironment(originalEnv).
Set the VariableEnvironment of currentContext to paramVarEnv.
Set the LexicalEnvironment of currentContext to paramVarEnv.
Let result be the result of performing IteratorBindingInitialization for BindingRestElement using iteratorRecord and environment as the arguments.
Set the VariableEnvironment of currentContext to originalEnv.
Set the LexicalEnvironment of currentContext to originalEnv.
Return result.

Note 3

The new 环境记录 created in step 6 is only used if the BindingRestElement contains a direct eval.

14.1.20运行时语义: InstantiateFunctionObject

With parameter scope.

function

(

)

{

}

If the function code for FunctionDeclaration is 严格模式代码, let strict be true. Otherwise let strict be false.
Let name be 字符值 of BindingIdentifier.
Let F be FunctionCreate(Normal, FormalParameters, FunctionBody, scope, strict).
Perform MakeConstructor(F).
Perform SetFunctionName(F, name).
Return F.

function

(

)

{

}

Let F be FunctionCreate(Normal, FormalParameters, FunctionBody, scope, true).
Perform MakeConstructor(F).
Perform SetFunctionName(F, "default").
Return F.

Note

An anonymous FunctionDeclaration can only occur as part of an export default declaration, and its function code is therefore always 严格模式代码.

14.1.21运行时语义: 估值

function

(

)

{

}

Return NormalCompletion(empty).

Note 1

An alternative 语义 is provided in B.3.3.

function

(

)

{

}

Return NormalCompletion(empty).

function

(

)

{

}

If the function code for FunctionExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, scope, strict).
Perform MakeConstructor(closure).
Return closure.

function

(

)

{

}

If the function code for FunctionExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let funcEnv be NewDeclarativeEnvironment(scope).
Let envRec be funcEnv's EnvironmentRecord.
Let name be 字符值 of BindingIdentifier.
Perform envRec.CreateImmutableBinding(name, false).
Let closure be FunctionCreate(Normal, FormalParameters, FunctionBody, funcEnv, strict).
Perform MakeConstructor(closure).
Perform SetFunctionName(closure, name).
Perform envRec.InitializeBinding(name, closure).
Return closure.

Note 2

The BindingIdentifier in a FunctionExpression can be referenced from inside the FunctionExpression's FunctionBody to allow the function to call itself recursively. However, unlike in a FunctionDeclaration, the BindingIdentifier in a FunctionExpression cannot be referenced from and does not affect the scope enclosing the FunctionExpression.

Note 3

A prototype property is automatically created for every function defined using a FunctionDeclaration or FunctionExpression, to allow for the possibility that the function will be used as a 构造器.

[empty]

Return NormalCompletion(undefined).

14.2箭头函数声明

Syntax

[In, Yield, Await]

[?Yield, ?Await]

[no LineTerminator here]

[?In]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[In]

[lookahead ≠ {]

[?In, ~Yield, ~Await]

{

[~Yield, ~Await]

}

Supplemental Syntax

When the production
ArrowParameters[Yield, Await]:CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await]
is recognized the following grammar is used to refine the interpretation of CoverParenthesizedExpressionAndArrowParameterList:

[Yield, Await]

(

[?Yield, ?Await]

)

14.2.1静态语义: 早期错误

这是一个句法错误如果 ArrowParameters Contains YieldExpression is true.
这是一个句法错误如果 ArrowParameters Contains AwaitExpression is true.
这是一个句法错误如果 ContainsUseStrict of ConciseBody is true and IsSimpleParameterList of ArrowParameters is false.
这是一个句法错误如果 any element of the 绑定名 of ArrowParameters also occurs in the LexicallyDeclaredNames of ConciseBody.

这是一个句法错误如果 CoverParenthesizedExpressionAndArrowParameterList is not covering an ArrowFormalParameters.
All 早期错误 rules for ArrowFormalParameters and its derived productions also apply to CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.

14.2.2静态语义: 绑定名

Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
Return the 绑定名 of formals.

14.2.3静态语义: Contains

With parameter symbol.

If symbol is not one of NewTarget, SuperProperty, SuperCall, super or this, return false.
If ArrowParameters Contains symbol is true, return true.
Return ConciseBody Contains symbol.

Note

Normally, Contains does not look inside most function forms. However, Contains is used to detect new.target, this, and super usage within an ArrowFunction.

Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
Return formals Contains symbol.

14.2.4静态语义: ContainsExpression

Return false.

14.2.5静态语义: ContainsUseStrict

Return false.

14.2.6静态语义: ExpectedArgumentCount

Return 1.

14.2.7静态语义: HasName

Return false.

14.2.8静态语义: IsSimpleParameterList

Return true.

Let formals be CoveredFormalsList of CoverParenthesizedExpressionAndArrowParameterList.
Return IsSimpleParameterList of formals.

14.2.9静态语义: CoveredFormalsList

Return this ArrowParameters.

(

)

(

)

(

...

)

(

...

)

(

...

)

(

...

)

Return the ArrowFormalParameters that is covered by CoverParenthesizedExpressionAndArrowParameterList.

14.2.10静态语义: LexicallyDeclaredNames

Return a new empty List.

14.2.11静态语义: LexicallyScopedDeclarations

Return a new empty List.

14.2.12静态语义: VarDeclaredNames

Return a new empty List.

14.2.13静态语义: VarScopedDeclarations

Return a new empty List.

14.2.14运行时语义: IteratorBindingInitialization

With parameters iteratorRecord and environment.

Note

Assert: iteratorRecord.[[Done]] is false.
Let next be IteratorStep(iteratorRecord).
If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
ReturnIfAbrupt(next).
If next is false, set iteratorRecord.[[Done]] to true.
Else,
1. Let v be IteratorValue(next).
2. If v is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(v).
If iteratorRecord.[[Done]] is true, let v be undefined.
Return the result of performing 绑定初始化 for BindingIdentifier using v and environment as the arguments.

14.2.15运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
Let exprRef be the result of evaluating AssignmentExpression.
Let exprValue be ? GetValue(exprRef).
Return Completion{[[Type]]: return, [[Value]]: exprValue, [[Target]]: empty}.

14.2.16运行时语义: 估值

If the function code for this ArrowFunction is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let parameters be CoveredFormalsList of ArrowParameters.
Let closure be FunctionCreate(Arrow, parameters, ConciseBody, scope, strict).
Return closure.

Note

An ArrowFunction does not define local bindings for arguments, super, this, or new.target. Any reference to arguments, super, this, or new.target within an ArrowFunction must resolve to a binding in a lexically enclosing environment. Typically this will be the Function Environment of an immediately enclosing function. Even though an ArrowFunction may contain references to super, the 函数对象 created in step 4 is not made into a method by performing MakeMethod. An ArrowFunction that references super is always contained within a non-ArrowFunction and the necessary state to implement super is accessible via the scope that is captured by the 函数对象 of the ArrowFunction.

14.3方法定义

Syntax

[Yield, Await]

[?Yield, ?Await]

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

get

[?Yield, ?Await]

(

)

{

[~Yield, ~Await]

}

set

[?Yield, ?Await]

(

)

{

[~Yield, ~Await]

}

[~Yield, ~Await]

14.3.1静态语义: 早期错误

(

)

{

}

这是一个句法错误如果 ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of FunctionBody.

set

(

)

{

}

这是一个句法错误如果绑定名 of PropertySetParameterList contains any duplicate elements.
这是一个句法错误如果 ContainsUseStrict of FunctionBody is true and IsSimpleParameterList of PropertySetParameterList is false.
这是一个句法错误如果 any element of the 绑定名 of PropertySetParameterList also occurs in the LexicallyDeclaredNames of FunctionBody.

14.3.2静态语义: 可计算的属性包含

With parameter symbol.

(

)

{

}

get

(

)

{

}

set

(

)

{

}

Return the result of 可计算的属性包含 for PropertyName with argument symbol.

14.3.3静态语义: ExpectedArgumentCount

If HasInitializer of FormalParameter is true, return 0.
Return 1.

14.3.4静态语义: HasDirectSuper

(

)

{

}

If UniqueFormalParameters Contains SuperCall is true, return true.
Return FunctionBody Contains SuperCall.

get

(

)

{

}

Return FunctionBody Contains SuperCall.

set

(

)

{

}

If PropertySetParameterList Contains SuperCall is true, return true.
Return FunctionBody Contains SuperCall.

14.3.5静态语义: 属性名

(

)

{

}

get

(

)

{

}

set

(

)

{

}

Return 属性名 of PropertyName.

14.3.6静态语义: SpecialMethod

(

)

{

}

Return false.

get

(

)

{

}

set

(

)

{

}

Return true.

14.3.7运行时语义: DefineMethod

With parameters object and optional parameter functionPrototype.

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this MethodDefinition is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
If functionPrototype is present as a parameter, then
1. Let kind be Normal.
2. Let prototype be functionPrototype.
Else,
1. Let kind be Method.
2. Let prototype be the 内部对象 %FunctionPrototype%.
Let closure be FunctionCreate(kind, UniqueFormalParameters, FunctionBody, scope, strict, prototype).
Perform MakeMethod(closure, object).
Return the Record{[[Key]]: propKey, [[Closure]]: closure}.

14.3.8运行时语义: 属性定义估值

With parameters object and enumerable.

(

)

{

}

Let methodDef be DefineMethod of MethodDefinition with argument object.
ReturnIfAbrupt(methodDef).
Perform SetFunctionName(methodDef.[[Closure]], methodDef.[[Key]]).
Let desc be the PropertyDescriptor{[[Value]]: methodDef.[[Closure]], [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, methodDef.[[Key]], desc).

get

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this MethodDefinition is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let formalParameterList be an instance of the production FormalParameters:[empty] .
Let closure be FunctionCreate(Method, formalParameterList, FunctionBody, scope, strict).
Perform MakeMethod(closure, object).
Perform SetFunctionName(closure, propKey, "get").
Let desc be the PropertyDescriptor{[[Get]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

set

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this MethodDefinition is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let closure be FunctionCreate(Method, PropertySetParameterList, FunctionBody, scope, strict).
Perform MakeMethod(closure, object).
Perform SetFunctionName(closure, propKey, "set").
Let desc be the PropertyDescriptor{[[Set]]: closure, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

14.4生成器函数定义

Syntax

[Yield, Await]

[?Yield, ?Await]

(

[+Yield, ~Await]

)

{

}

[Yield, Await, Default]

function

[?Yield, ?Await]

(

[+Yield, ~Await]

)

{

}

[+Default]

function

(

[+Yield, ~Await]

)

{

}

function

[+Yield, ~Await]

opt

(

[+Yield, ~Await]

)

{

}

[+Yield, ~Await]

[In, Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

Note 1

The syntactic context immediately following yield requires use of the InputElementRegExpOrTemplateTail lexical goal.

Note 2

YieldExpression cannot be used within the FormalParameters of a 生成器函数 because any expressions that are part of FormalParameters are evaluated before the resulting 生成器对象 is in a resumable state.

Note 3

抽象操作 relating to 生成器对象 are defined in 25.4.3.

14.4.1静态语义: 早期错误

(

)

{

}

这是一个句法错误如果 HasDirectSuper of GeneratorMethod is true.
这是一个句法错误如果 UniqueFormalParameters Contains YieldExpression is true.
这是一个句法错误如果 ContainsUseStrict of GeneratorBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of GeneratorBody.

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

If the source code matching this production is 严格模式代码, the 早期错误 rules for UniqueFormalParameters:FormalParameters are applied.
If the source code matching this production is 严格模式代码, 这是一个句法错误如果 BindingIdentifier is present and the 字符值 of BindingIdentifier is "eval" or "arguments".
这是一个句法错误如果 ContainsUseStrict of GeneratorBody is true and IsSimpleParameterList of FormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of FormalParameters also occurs in the LexicallyDeclaredNames of GeneratorBody.
这是一个句法错误如果 FormalParameters Contains YieldExpression is true.
这是一个句法错误如果 FormalParameters Contains SuperProperty is true.
这是一个句法错误如果 GeneratorBody Contains SuperProperty is true.
这是一个句法错误如果 FormalParameters Contains SuperCall is true.
这是一个句法错误如果 GeneratorBody Contains SuperCall is true.

14.4.2静态语义: 绑定名

function

(

)

{

}

Return the 绑定名 of BindingIdentifier.

function

(

)

{

}

Return « "*default*" ».

Note

"*default*" is used within this specification as a synthetic name for hoistable anonymous functions that are defined using export declarations.

14.4.3静态语义: 可计算的属性包含

With parameter symbol.

(

)

{

}

Return the result of 可计算的属性包含 for PropertyName with argument symbol.

14.4.4静态语义: Contains

With parameter symbol.

function

(

)

{

}

function

(

)

{

}

function

opt

(

)

{

}

Return false.

Note

静态语义规则 that depend upon substructure generally do not look into 函数定义.

14.4.5静态语义: HasDirectSuper

(

)

{

}

If UniqueFormalParameters Contains SuperCall is true, return true.
Return GeneratorBody Contains SuperCall.

14.4.6静态语义: HasName

function

(

)

{

}

Return false.

function

(

)

{

}

Return true.

14.4.7静态语义: IsConstantDeclaration

function

(

)

{

}

function

(

)

{

}

Return false.

14.4.8静态语义: 是函数定义

function

opt

(

)

{

}

Return true.

14.4.9静态语义: 属性名

(

)

{

}

Return 属性名 of PropertyName.

14.4.10运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
Let G be ? OrdinaryCreateFromConstructor(functionObject, "%GeneratorPrototype%", « [[GeneratorState]], [[GeneratorContext]] »).
Perform GeneratorStart(G, FunctionBody).
Return Completion{[[Type]]: return, [[Value]]: G, [[Target]]: empty}.

14.4.11运行时语义: InstantiateFunctionObject

With parameter scope.

function

(

)

{

}

If the function code for GeneratorDeclaration is 严格模式代码, let strict be true. Otherwise let strict be false.
Let name be 字符值 of BindingIdentifier.
Let F be GeneratorFunctionCreate(Normal, FormalParameters, GeneratorBody, scope, strict).
Let prototype be ObjectCreate(%GeneratorPrototype%).
Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(F, name).
Return F.

function

(

)

{

}

Let F be GeneratorFunctionCreate(Normal, FormalParameters, GeneratorBody, scope, true).
Let prototype be ObjectCreate(%GeneratorPrototype%).
Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(F, "default").
Return F.

Note

An anonymous GeneratorDeclaration can only occur as part of an export default declaration, and its function code is therefore always 严格模式代码.

14.4.12运行时语义: 属性定义估值

With parameters object and enumerable.

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this GeneratorMethod is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let closure be GeneratorFunctionCreate(Method, UniqueFormalParameters, GeneratorBody, scope, strict).
Perform MakeMethod(closure, object).
Let prototype be ObjectCreate(%GeneratorPrototype%).
Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(closure, propKey).
Let desc be the PropertyDescriptor{[[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

14.4.13运行时语义: 估值

function

(

)

{

}

If the function code for this GeneratorExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let closure be GeneratorFunctionCreate(Normal, FormalParameters, GeneratorBody, scope, strict).
Let prototype be ObjectCreate(%GeneratorPrototype%).
Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Return closure.

function

(

)

{

}

If the function code for this GeneratorExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let funcEnv be NewDeclarativeEnvironment(scope).
Let envRec be funcEnv's EnvironmentRecord.
Let name be 字符值 of BindingIdentifier.
Perform envRec.CreateImmutableBinding(name, false).
Let closure be GeneratorFunctionCreate(Normal, FormalParameters, GeneratorBody, funcEnv, strict).
Let prototype be ObjectCreate(%GeneratorPrototype%).
Perform DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(closure, name).
Perform envRec.InitializeBinding(name, closure).
Return closure.

Note

The BindingIdentifier in a GeneratorExpression can be referenced from inside the GeneratorExpression's FunctionBody to allow the generator code to call itself recursively. However, unlike in a GeneratorDeclaration, the BindingIdentifier in a GeneratorExpression cannot be referenced from and does not affect the scope enclosing the GeneratorExpression.

yield

Let generatorKind be ! GetGeneratorKind().
If generatorKind is async, then return ? AsyncGeneratorYield(undefined).
Otherwise, return ? GeneratorYield(CreateIterResultObject(undefined, false)).

yield

Let generatorKind be ! GetGeneratorKind().
Let exprRef be the result of evaluating AssignmentExpression.
Let value be ? GetValue(exprRef).
If generatorKind is async, then return ? AsyncGeneratorYield(value).
Otherwise, return ? GeneratorYield(CreateIterResultObject(value, false)).

yield

Let generatorKind be ! GetGeneratorKind().
Let exprRef be the result of evaluating AssignmentExpression.
Let value be ? GetValue(exprRef).
Let iteratorRecord be ? GetIterator(value, generatorKind).
Let 迭代器 be iteratorRecord.[[迭代器]].
Let received be NormalCompletion(undefined).
Repeat,
1. If received.[[Type]] is normal, then
  1. Let innerResult be ? Call(iteratorRecord.[[NextMethod]], iteratorRecord.[[迭代器]], « received.[[Value]] »).
  2. If generatorKind is async, then set innerResult to ? Await(innerResult).
  3. If Type(innerResult) is not Object, 抛出一个 TypeError 异常.
  4. Let done be ? IteratorComplete(innerResult).
  5. If done is true, then
    1. Return ? IteratorValue(innerResult).
  6. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
  7. Else, set received to GeneratorYield(innerResult).
2. Else if received.[[Type]] is throw, then
  1. Let throw be ? GetMethod(迭代器, "throw").
  2. If throw is not undefined, then
    1. Let innerResult be ? Call(throw, 迭代器, « received.[[Value]] »).
    2. If generatorKind is async, then set innerResult to ? Await(innerResult).
    3. NOTE: Exceptions from the inner 迭代器 throw method are propagated. Normal completions from an inner throw method are processed similarly to an inner next.
    4. If Type(innerResult) is not Object, 抛出一个 TypeError 异常.
    5. Let done be ? IteratorComplete(innerResult).
    6. If done is true, then
      1. Return ? IteratorValue(innerResult).
    7. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerResult)).
    8. Else, set received to GeneratorYield(innerResult).
  3. Else,
    1. NOTE: If 迭代器 does not have a throw method, this throw is going to terminate the yield* loop. But first we need to give 迭代器 a chance to clean up.
    2. Let closeCompletion be Completion{[[Type]]: normal, [[Value]]: empty, [[Target]]: empty}.
    3. If generatorKind is async, perform ? AsyncIteratorClose(iteratorRecord, closeCompletion).
    4. Else, perform ? IteratorClose(iteratorRecord, closeCompletion).
    5. NOTE: The next step throws a TypeError to indicate that there was a yield* protocol violation: 迭代器 does not have a throw method.
    6. 抛出一个 TypeError 异常.
3. Else,
  1. Assert: received.[[Type]] is return.
  2. Let return be ? GetMethod(迭代器, "return").
  3. If return is undefined, then
    1. If generatorKind is async, then set received.[[Value]] to ? Await(received.[[Value]]).
    2. Return Completion(received).
  4. Let innerReturnResult be ? Call(return, 迭代器, « received.[[Value]] »).
  5. If generatorKind is async, then set innerReturnResult to ? Await(innerReturnResult).
  6. If Type(innerReturnResult) is not Object, 抛出一个 TypeError 异常.
  7. Let done be ? IteratorComplete(innerReturnResult).
  8. If done is true, then
    1. Let value be ? IteratorValue(innerReturnResult).
    2. Return Completion{[[Type]]: return, [[Value]]: value, [[Target]]: empty}.
  9. If generatorKind is async, then set received to AsyncGeneratorYield(? IteratorValue(innerReturnResult)).
  10. Else, set received to GeneratorYield(innerReturnResult).

14.5异步生成器函数定义

Syntax

[Yield, Await]

async

[no LineTerminator here]

[?Yield, ?Await]

(

[+Yield, +Await]

)

{

}

[Yield, Await, Default]

async

[no LineTerminator here]

function

[?Yield, ?Await]

(

[+Yield, +Await]

)

{

}

[+Default]

async

[no LineTerminator here]

function

(

[+Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

[+Yield, +Await]

opt

(

[+Yield, +Await]

)

{

}

[+Yield, +Await]

Note 1

YieldExpression and AwaitExpression cannot be used within the FormalParameters of an async 生成器函数 because any expressions that are part of FormalParameters are evaluated before the resulting async 生成器对象 is in a resumable state.

Note 2

抽象操作 relating to async 生成器对象 are defined in 25.5.3.

14.5.1静态语义: 早期错误

async

(

)

{

}

这是一个句法错误如果 HasDirectSuper of AsyncGeneratorMethod is true.
这是一个句法错误如果 UniqueFormalParameters Contains YieldExpression is true.
这是一个句法错误如果 UniqueFormalParameters Contains AwaitExpression is true.
这是一个句法错误如果 ContainsUseStrict of AsyncGeneratorBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of AsyncGeneratorBody.

async

function

(

)

{

}

async

function

(

)

{

}

async

function

opt

(

)

{

}

If the source code matching this production is 严格模式代码, the 早期错误 rules for UniqueFormalParameters:FormalParameters are applied.
If the source code matching this production is 严格模式代码, 这是一个句法错误如果 BindingIdentifier is the IdentifierName eval or the IdentifierName arguments.
这是一个句法错误如果 ContainsUseStrict of AsyncGeneratorBody is true and IsSimpleParameterList of FormalParameters is false.
这是一个句法错误如果 any element of the 绑定名 of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncGeneratorBody.
这是一个句法错误如果 FormalParameters Contains YieldExpression is true.
这是一个句法错误如果 FormalParameters Contains AwaitExpression is true.
这是一个句法错误如果 FormalParameters Contains SuperProperty is true.
这是一个句法错误如果 AsyncGeneratorBody Contains SuperProperty is true.
这是一个句法错误如果 FormalParameters Contains SuperCall is true.
这是一个句法错误如果 AsyncGeneratorBody Contains SuperCall is true.

14.5.2静态语义: 绑定名

async

function

(

)

{

}

Return the 绑定名 of BindingIdentifier.

async

function

(

)

{

}

Return « "*default*" ».

Note

"*default*" is used within this specification as a synthetic name for hoistable anonymous functions that are defined using export declarations.

14.5.3静态语义: 可计算的属性包含

With parameter symbol.

async

(

)

{

}

Return the result of 可计算的属性包含 for PropertyName with argument symbol.

14.5.4静态语义: Contains

With parameter symbol.

async

function

(

)

{

}

async

function

(

)

{

}

async

function

opt

(

)

{

}

Return false.

Note

静态语义规则 that depend upon substructure generally do not look into 函数定义.

14.5.5静态语义: HasDirectSuper

async

(

)

{

}

If UniqueFormalParameters Contains SuperCall is true, return true.
Return AsyncGeneratorBody Contains SuperCall.

14.5.6静态语义: HasName

async

function

(

)

{

}

Return false.

async

function

(

)

{

}

Return true.

14.5.7静态语义: IsConstantDeclaration

async

function

(

)

{

}

async

function

(

)

{

}

Return false.

14.5.8静态语义: 是函数定义

async

function

opt

(

)

{

}

Return true.

14.5.9静态语义: 属性名

async

(

)

{

}

Return 属性名 of PropertyName.

14.5.10运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

Perform ? FunctionDeclarationInstantiation(functionObject, argumentsList).
Let generator be ? OrdinaryCreateFromConstructor(functionObject, "%AsyncGeneratorPrototype%", « [[AsyncGeneratorState]], [[AsyncGeneratorContext]], [[AsyncGeneratorQueue]] »).
Perform ! AsyncGeneratorStart(generator, FunctionBody).
Return Completion{[[Type]]: return, [[Value]]: generator, [[Target]]: empty}.

14.5.11运行时语义: InstantiateFunctionObject

With parameter scope.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncGeneratorDeclaration is 严格模式代码, let strict be true. Otherwise let strict be false.
Let name be 字符值 of BindingIdentifier.
Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform ! SetFunctionName(F, name).
Return F.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncGeneratorDeclaration is 严格模式代码, let strict be true. Otherwise let strict be false.
Let F be AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ObjectCreate(%AsyncGeneratorPrototype%).
Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform SetFunctionName(F, "default").
Return F.

Note

An anonymous AsyncGeneratorDeclaration can only occur as part of an export default declaration.

14.5.12运行时语义: 属性定义估值

With parameter object and enumerable.

async

[no LineTerminator here]

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this AsyncGeneratorMethod is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, AsyncGeneratorBody, scope, strict).
Perform ! MakeMethod(closure, object).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform ! SetFunctionName(closure, propKey).
Let desc be PropertyDescriptor{[[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

14.5.13运行时语义: 估值

async

[no LineTerminator here]

function

(

)

{

}

If the function code for this AsyncGeneratorExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, scope, strict).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Return closure.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for this AsyncGeneratorExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the 运行时执行上下文's LexicalEnvironment.
Let funcEnv be ! NewDeclarativeEnvironment(scope).
Let envRec be funcEnv's EnvironmentRecord.
Let name be 字符值 of BindingIdentifier.
Perform ! envRec.CreateImmutableBinding(name).
Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, funcEnv, strict).
Let prototype be ! ObjectCreate(%AsyncGeneratorPrototype%).
Perform ! DefinePropertyOrThrow(closure, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Perform ! SetFunctionName(closure, name).
Perform ! envRec.InitializeBinding(name, closure).
Return closure.

Note

The BindingIdentifier in an AsyncGeneratorExpression can be referenced from inside the AsyncGeneratorExpression's AsyncGeneratorBody to allow the generator code to call itself recursively. However, unlike in an AsyncGeneratorDeclaration, the BindingIdentifier in an AsyncGeneratorExpression cannot be referenced from and does not affect the scope enclosing the AsyncGeneratorExpression.

14.6类定义

Syntax

[Yield, Await, Default]

class

[?Yield, ?Await]

[?Yield, ?Await]

[+Default]

class

[?Yield, ?Await]

[Yield, Await]

class

[?Yield, ?Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

opt

{

[?Yield, ?Await]

opt

}

[Yield, Await]

extends

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

static

[?Yield, ?Await]

;

Note

A class definition is always 严格模式代码.

14.6.1静态语义: 早期错误

opt

{

}

这是一个句法错误如果 ClassHeritage is not present and the following 算法 evaluates to true:
1. Let 构造器 be ConstructorMethod of ClassBody.
2. If 构造器 is empty, return false.
3. Return HasDirectSuper of 构造器.

这是一个句法错误如果 PrototypePropertyNameList of ClassElementList contains more than one occurrence of "构造器".

这是一个句法错误如果属性名 of MethodDefinition is not "构造器" and HasDirectSuper of MethodDefinition is true.
这是一个句法错误如果属性名 of MethodDefinition is "构造器" and SpecialMethod of MethodDefinition is true.

static

这是一个句法错误如果 HasDirectSuper of MethodDefinition is true.
这是一个句法错误如果属性名 of MethodDefinition is "prototype".

14.6.2静态语义: 绑定名

class

Return the 绑定名 of BindingIdentifier.

class

Return « "*default*" ».

14.6.3静态语义: ConstructorMethod

If ClassElement is ClassElement:; , return empty.
If IsStatic of ClassElement is true, return empty.
If 属性名 of ClassElement is not "构造器", return empty.
Return ClassElement.

Let head be ConstructorMethod of ClassElementList.
If head is not empty, return head.
If ClassElement is ClassElement:; , return empty.
If IsStatic of ClassElement is true, return empty.
If 属性名 of ClassElement is not "构造器", return empty.
Return ClassElement.

Note

早期错误 rules ensure that there is only one method definition named "构造器" and that it is not an 访问器属性 or generator definition.

14.6.4静态语义: Contains

With parameter symbol.

opt

{

}

If symbol is ClassBody, return true.
If symbol is ClassHeritage, then
1. If ClassHeritage is present, return true; otherwise return false.
Let inHeritage be ClassHeritage Contains symbol.
If inHeritage is true, return true.
Return the result of 可计算的属性包含 for ClassBody with argument symbol.

Note

静态语义规则 that depend upon substructure generally do not look into class bodies except for PropertyNames.

14.6.5静态语义: 可计算的属性包含

With parameter symbol.

Let inList be the result of 可计算的属性包含 for ClassElementList with argument symbol.
If inList is true, return true.
Return the result of 可计算的属性包含 for ClassElement with argument symbol.

Return the result of 可计算的属性包含 for MethodDefinition with argument symbol.

static

Return the result of 可计算的属性包含 for MethodDefinition with argument symbol.

;

Return false.

14.6.6静态语义: HasName

class

Return false.

class

Return true.

14.6.7静态语义: IsConstantDeclaration

class

class

Return false.

14.6.8静态语义: 是函数定义

class

opt

Return true.

14.6.9静态语义: IsStatic

Return false.

static

Return true.

;

Return false.

14.6.10静态语义: NonConstructorMethodDefinitions

If ClassElement is ClassElement:; , return a new empty List.
If IsStatic of ClassElement is false and 属性名 of ClassElement is "构造器", return a new empty List.
Return a List containing ClassElement.

Let list be NonConstructorMethodDefinitions of ClassElementList.
If ClassElement is ClassElement:; , return list.
If IsStatic of ClassElement is false and 属性名 of ClassElement is "构造器", return list.
Append ClassElement to the end of list.
Return list.

14.6.11静态语义: PrototypePropertyNameList

If 属性名 of ClassElement is empty, return a new empty List.
If IsStatic of ClassElement is true, return a new empty List.
Return a List containing 属性名 of ClassElement.

Let list be PrototypePropertyNameList of ClassElementList.
If 属性名 of ClassElement is empty, return list.
If IsStatic of ClassElement is true, return list.
Append 属性名 of ClassElement to the end of list.
Return list.

14.6.12静态语义: 属性名

;

Return empty.

14.6.13运行时语义: ClassDefinitionEvaluation

With parameter className.

opt

{

opt

}

Let lex be the LexicalEnvironment of the 运行时执行上下文.
Let classScope be NewDeclarativeEnvironment(lex).
Let classScopeEnvRec be classScope's EnvironmentRecord.
If className is not undefined, then
1. Perform classScopeEnvRec.CreateImmutableBinding(className, true).
If ClassHeritageopt is not present, then
1. Let protoParent be the 内部对象 %ObjectPrototype%.
2. Let constructorParent be the 内部对象 %FunctionPrototype%.
Else,
1. Set the 运行时执行上下文's LexicalEnvironment to classScope.
2. Let superclass be the result of evaluating ClassHeritage.
3. Set the 运行时执行上下文's LexicalEnvironment to lex.
4. ReturnIfAbrupt(superclass).
5. If superclass is null, then
  1. Let protoParent be null.
  2. Let constructorParent be the 内部对象 %FunctionPrototype%.
6. Else if IsConstructor(superclass) is false, 抛出一个 TypeError 异常.
7. Else,
  1. Let protoParent be ? Get(superclass, "prototype").
  2. If Type(protoParent) is neither Object nor Null, 抛出一个 TypeError 异常.
  3. Let constructorParent be superclass.
Let proto be ObjectCreate(protoParent).
If ClassBodyopt is not present, let 构造器 be empty.
Else, let 构造器 be ConstructorMethod of ClassBody.
If 构造器 is empty, then
1. If ClassHeritageopt is present, then
  1. Set 构造器 to the result of parsing the 源文本
```
构造器(... args){ super (...args);}
```
    using 句法 with the 目标符 MethodDefinition[~Yield, ~Await].
2. Else,
  1. Set 构造器 to the result of parsing the 源文本
```
构造器( ){ }
```
    using 句法 with the 目标符 MethodDefinition[~Yield, ~Await].
Set the 运行时执行上下文's LexicalEnvironment to classScope.
Let constructorInfo be the result of performing DefineMethod for 构造器 with arguments proto and constructorParent as the optional functionPrototype argument.
Assert: constructorInfo is not an abrupt completion.
Let F be constructorInfo.[[Closure]].
If ClassHeritageopt is present, set F.[[ConstructorKind]] to "derived".
Perform MakeConstructor(F, false, proto).
Perform MakeClassConstructor(F).
Perform CreateMethodProperty(proto, "构造器", F).
If ClassBodyopt is not present, let methods be a new empty List.
Else, let methods be NonConstructorMethodDefinitions of ClassBody.
For each ClassElement m in order from methods, do
1. If IsStatic of m is false, then
  1. Let status be the result of performing 属性定义估值 for m with arguments proto and false.
2. Else,
  1. Let status be the result of performing 属性定义估值 for m with arguments F and false.
3. If status is an abrupt completion, then
  1. Set the 运行时执行上下文's LexicalEnvironment to lex.
  2. Return Completion(status).
Set the 运行时执行上下文's LexicalEnvironment to lex.
If className is not undefined, then
1. Perform classScopeEnvRec.InitializeBinding(className, F).
Return F.

14.6.14运行时语义: BindingClassDeclarationEvaluation

class

Let className be 字符值 of BindingIdentifier.
Let value be the result of ClassDefinitionEvaluation of ClassTail with argument className.
ReturnIfAbrupt(value).
Let hasNameProperty be ? HasOwnProperty(value, "name").
If hasNameProperty is false, perform SetFunctionName(value, className).
Let env be the 运行时执行上下文's LexicalEnvironment.
Perform ? InitializeBoundName(className, value, env).
Return value.

class

Return the result of ClassDefinitionEvaluation of ClassTail with argument undefined.

Note

ClassDeclaration:classClassTail only occurs as part of an ExportDeclaration and the setting of a name property and establishing its binding are handled as part of the 估值 action for that production. See 15.2.3.11.

14.6.15运行时语义: 估值

class

Perform ? BindingClassDeclarationEvaluation of this ClassDeclaration.
Return NormalCompletion(empty).

Note 1

ClassDeclaration:classClassTail only occurs as part of an ExportDeclaration and is never directly evaluated.

class

opt

If BindingIdentifieropt is not present, let className be undefined.
Else, let className be 字符值 of BindingIdentifier.
Let value be the result of ClassDefinitionEvaluation of ClassTail with argument className.
ReturnIfAbrupt(value).
If className is not undefined, then
1. Let hasNameProperty be ? HasOwnProperty(value, "name").
2. If hasNameProperty is false, then
  1. Perform SetFunctionName(value, className).
Return NormalCompletion(value).

Note 2

If the class definition included a name static method then that method is not over-written with a name 数据属性 for the class name.

14.7异步函数定义

Syntax

[Yield, Await, Default]

async

[no LineTerminator here]

function

[?Yield, ?Await]

(

[~Yield, +Await]

)

{

}

[+Default]

async

[no LineTerminator here]

function

(

[~Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

(

[~Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

[~Yield, +Await]

(

[~Yield, +Await]

)

{

}

[Yield, Await]

async

[no LineTerminator here]

[?Yield, ?Await]

(

[~Yield, +Await]

)

{

}

[~Yield, +Await]

[Yield]

await

[?Yield, +Await]

Note 1

await is parsed as an AwaitExpression when the _[Await] parameter is present. The _[Await] parameter is present in the following contexts:

In an AsyncFunctionBody.
In the FormalParameters of an AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, or AsyncGeneratorExpression. AwaitExpression in this position is a Syntax error via 静态语义.

When Module is the syntactic 目标符 and the _[Await] parameter is absent, await is parsed as a keyword and will be a Syntax error. When Script is the syntactic 目标符, await may be parsed as an identifier when the _[Await] parameter is absent. This includes the following contexts:

Anywhere outside of an AsyncFunctionBody or FormalParameters of an AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, or AsyncGeneratorExpression.
In the BindingIdentifier of a FunctionExpression, GeneratorExpression, or AsyncGeneratorExpression.

Note 2

Unlike YieldExpression, it is a Syntax Error to omit the operand of an AwaitExpression. You must await something.

14.7.1静态语义: 早期错误

async

[no LineTerminator here]

(

)

{

}

这是一个句法错误如果 ContainsUseStrict of AsyncFunctionBody is true and IsSimpleParameterList of UniqueFormalParameters is false.
这是一个句法错误如果 HasDirectSuper of AsyncMethod is true.
这是一个句法错误如果 UniqueFormalParameters Contains AwaitExpression is true.
这是一个句法错误如果 any element of the 绑定名 of UniqueFormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody.

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

这是一个句法错误如果 ContainsUseStrict of AsyncFunctionBody is true and IsSimpleParameterList of FormalParameters is false.
这是一个句法错误如果 FormalParameters Contains AwaitExpression is true.
If the source code matching this production is strict code, the 早期错误 rules for UniqueFormalParameters:FormalParameters are applied.
If the source code matching this production is strict code, 这是一个句法错误如果 BindingIdentifier is present and the 字符值 of BindingIdentifier is "eval" or "arguments".
这是一个句法错误如果 any element of the 绑定名 of FormalParameters also occurs in the LexicallyDeclaredNames of AsyncFunctionBody.
这是一个句法错误如果 FormalParameters Contains SuperProperty is true.
这是一个句法错误如果 AsyncFunctionBody Contains SuperProperty is true.
这是一个句法错误如果 FormalParameters Contains SuperCall is true.
这是一个句法错误如果 AsyncFunctionBody Contains SuperCall is true.

14.7.2静态语义: 绑定名

async

[no LineTerminator here]

function

(

)

{

}

Return the 绑定名 of BindingIdentifier.

async

[no LineTerminator here]

function

(

)

{

}

Return «"*default*"».

Note

"*default*" is used within this specification as a synthetic name for hoistable anonymous functions that are defined using export declarations.

14.7.3静态语义: 可计算的属性包含

With parameter symbol.

async

[no LineTerminator here]

(

)

{

}

Return the result of 可计算的属性包含 for PropertyName with argument symbol.

14.7.4静态语义: Contains

With parameter symbol.

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

Return false.

14.7.5静态语义: HasDirectSuper

async

[no LineTerminator here]

(

)

{

}

If UniqueFormalParameters Contains SuperCall is true, return true.
Return AsyncFunctionBody Contains SuperCall.

14.7.6静态语义: HasName

async

[no LineTerminator here]

function

(

)

{

}

Return false.

async

[no LineTerminator here]

function

(

)

{

}

Return true.

14.7.7静态语义: IsConstantDeclaration

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

Return false.

14.7.8静态语义: 是函数定义

async

[no LineTerminator here]

function

(

)

{

}

async

[no LineTerminator here]

function

(

)

{

}

Return true.

14.7.9静态语义: 属性名

async

[no LineTerminator here]

(

)

{

}

Return 属性名 of PropertyName.

14.7.10运行时语义: InstantiateFunctionObject

With parameter scope.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncFunctionDeclaration is 严格模式代码, let strict be true. Otherwise, let strict be false.
Let name be 字符值 of BindingIdentifier.
Let F be ! AsyncFunctionCreate(Normal, FormalParameters, AsyncFunctionBody, scope, strict).
Perform ! SetFunctionName(F, name).
Return F.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncFunctionDeclaration is 严格模式代码, let strict be true. Otherwise, let strict be false.
Let F be ! AsyncFunctionCreate(Normal, FormalParameters, AsyncFunctionBody, scope, strict).
Perform ! SetFunctionName(F, "default").
Return F.

14.7.11运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

Let promiseCapability be ! NewPromiseCapability(%Promise%).
Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
If declResult is not an abrupt completion, then
1. Perform ! AsyncFunctionStart(promiseCapability, FunctionBody).
Else declResult is an abrupt completion,
1. Perform ! Call(promiseCapability.[[Reject]], undefined, «declResult.[[Value]]»).
Return Completion{[[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty}.

14.7.12运行时语义: 属性定义估值

With parameters object and enumerable.

async

[no LineTerminator here]

(

)

{

}

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
If the function code for this AsyncMethod is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let closure be ! AsyncFunctionCreate(Method, UniqueFormalParameters, AsyncFunctionBody, scope, strict).
Perform ! MakeMethod(closure, object).
Perform ! SetFunctionName(closure, propKey).
Let desc be the PropertyDescriptor{[[Value]]: closure, [[Writable]]: true, [[Enumerable]]: enumerable, [[Configurable]]: true}.
Return ? DefinePropertyOrThrow(object, propKey, desc).

14.7.13运行时语义: 估值

async

[no LineTerminator here]

function

(

)

{

}

Return NormalCompletion(empty).

async

[no LineTerminator here]

function

(

)

{

}

Return NormalCompletion(empty).

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncFunctionExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let closure be ! AsyncFunctionCreate(Normal, FormalParameters, AsyncFunctionBody, scope, strict).
Return closure.

async

[no LineTerminator here]

function

(

)

{

}

If the function code for AsyncFunctionExpression is 严格模式代码, let strict be true. Otherwise let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let funcEnv be ! NewDeclarativeEnvironment(scope).
Let envRec be funcEnv's EnvironmentRecord.
Let name be 字符值 of BindingIdentifier.
Perform ! envRec.CreateImmutableBinding(name).
Let closure be ! AsyncFunctionCreate(Normal, FormalParameters, AsyncFunctionBody, funcEnv, strict).
Perform ! SetFunctionName(closure, name).
Perform ! envRec.InitializeBinding(name, closure).
Return closure.

AwaitExpression

await

Let exprRef be the result of evaluating UnaryExpression.
Let value be ? GetValue(exprRef).
Return ? Await(value).

14.8异步箭头函数定义

Syntax

[In, Yield, Await]

async

[no LineTerminator here]

[?Yield]

[no LineTerminator here]

[?In]

[?Yield, ?Await]

[no LineTerminator here]

[?In]

[In]

[lookahead ≠ {]

[?In, ~Yield, +Await]

{

}

[Yield]

[?Yield, +Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

Supplemental Syntax

When processing an instance of the production AsyncArrowFunction:CoverCallExpressionAndAsyncArrowHead[no LineTerminator here]=>AsyncConciseBody the interpretation of CoverCallExpressionAndAsyncArrowHead is refined using the following grammar:

AsyncArrowHead

async

[no LineTerminator here]

[~Yield, +Await]

14.8.1静态语义: 早期错误

async

[no LineTerminator here]

[no LineTerminator here]

这是一个句法错误如果 any element of the 绑定名 of AsyncArrowBindingIdentifier also occurs in the LexicallyDeclaredNames of AsyncConciseBody.

[no LineTerminator here]

这是一个句法错误如果 CoverCallExpressionAndAsyncArrowHead Contains YieldExpression is true.
这是一个句法错误如果 CoverCallExpressionAndAsyncArrowHead Contains AwaitExpression is true.
这是一个句法错误如果 CoverCallExpressionAndAsyncArrowHead is not covering an AsyncArrowHead.
这是一个句法错误如果 any element of the 绑定名 of CoverCallExpressionAndAsyncArrowHead also occurs in the LexicallyDeclaredNames of AsyncConciseBody.
这是一个句法错误如果 ContainsUseStrict of AsyncConciseBody is true and IsSimpleParameterList of CoverCallExpressionAndAsyncArrowHead is false.
All 早期错误 rules for AsyncArrowHead and its derived productions apply to CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.

14.8.2静态语义: CoveredAsyncArrowHead

Return the AsyncArrowHead that is covered by CoverCallExpressionAndAsyncArrowHead.

14.8.3静态语义: 绑定名

Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
Return the 绑定名 of head.

14.8.4静态语义: Contains

With parameter symbol.

async

[no LineTerminator here]

[no LineTerminator here]

If symbol is not one of NewTarget, SuperProperty, SuperCall, super, or this, return false.
Return AsyncConciseBody Contains symbol.

[no LineTerminator here]

If symbol is not one of NewTarget, SuperProperty, SuperCall, super, or this, return false.
Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
If head Contains symbol is true, return true.
Return AsyncConciseBody Contains symbol.

Note

Normally, Contains does not look inside most function forms. However, Contains is used to detect new.target, this, and super usage within an AsyncArrowFunction.

14.8.5静态语义: ContainsExpression

Return false.

14.8.6静态语义: ExpectedArgumentCount

Return 1.

14.8.7静态语义: HasName

async

[no LineTerminator here]

[no LineTerminator here]

[no LineTerminator here]

Return false.

14.8.8静态语义: IsSimpleParameterList

[Yield]

[?Yield, +Await]

Return true.

Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
Return IsSimpleParameterList of head.

14.8.9静态语义: LexicallyDeclaredNames

[lookahead ≠ {]

Return a new empty List.

14.8.10静态语义: LexicallyScopedDeclarations

[lookahead ≠ {]

Return a new empty List.

14.8.11静态语义: VarDeclaredNames

[lookahead ≠ {]

Return a new empty List.

14.8.12静态语义: VarScopedDeclarations

[lookahead ≠ {]

Return a new empty List.

14.8.13运行时语义: IteratorBindingInitialization

With parameters iteratorRecord and environment.

Assert: iteratorRecord.[[Done]] is false.
Let next be ? IteratorStep(iteratorRecord).
If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
ReturnIfAbrupt(next).
If next is false, set iteratorRecord.[[Done]] to true.
Else,
1. Let v be ? IteratorValue(next).
2. If v is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(v).
If iteratorRecord.[[Done]] is true, let v be undefined.
Return the result of performing 绑定初始化 for BindingIdentifier using v and environment as the arguments.

14.8.14运行时语义: EvaluateBody

With parameters functionObject and List argumentsList.

[lookahead ≠ {]

Let promiseCapability be ! NewPromiseCapability(%Promise%).
Let declResult be FunctionDeclarationInstantiation(functionObject, argumentsList).
If declResult is not an abrupt completion, then
1. Perform ! AsyncFunctionStart(promiseCapability, AssignmentExpression).
Else declResult is an abrupt completion,
1. Perform ! Call(promiseCapability.[[Reject]], undefined, «declResult.[[Value]]»).
Return Completion{[[Type]]: return, [[Value]]: promiseCapability.[[Promise]], [[Target]]: empty}.

{

}

Return the result of EvaluateBody of AsyncFunctionBody passing functionObject and argumentsList as the arguments.

14.8.15运行时语义: 估值

async

[no LineTerminator here]

[no LineTerminator here]

If the function code for this AsyncArrowFunction is 严格模式代码, let strict be true. Otherwise, let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let parameters be AsyncArrowBindingIdentifier.
Let closure be ! AsyncFunctionCreate(Arrow, parameters, AsyncConciseBody, scope, strict).
Return closure.

[no LineTerminator here]

If the function code for this AsyncArrowFunction is 严格模式代码, let strict be true. Otherwise, let strict be false.
Let scope be the LexicalEnvironment of the 运行时执行上下文.
Let head be CoveredAsyncArrowHead of CoverCallExpressionAndAsyncArrowHead.
Let parameters be the ArrowFormalParameters of head.
Let closure be ! AsyncFunctionCreate(Arrow, parameters, AsyncConciseBody, scope, strict).
Return closure.

14.9尾调用

14.9.1静态语义: IsInTailPosition( `call` )

The 抽象操作 IsInTailPosition with argument call 执行如下:

Assert: call is a 解析节点.
If the source code matching call is non-strict code, return false.
If call is not contained within a FunctionBody, ConciseBody, or AsyncConciseBody, return false.
Let body be the FunctionBody, ConciseBody, or AsyncConciseBody that most closely contains call.
If body is the FunctionBody of a GeneratorBody, return false.
If body is the FunctionBody of an AsyncFunctionBody, return false.
If body is the FunctionBody of an AsyncGeneratorBody, return false.
If body is an AsyncConciseBody, return false.
Return the result of HasCallInTailPosition of body with argument call.

Note

尾调用 are only defined in 严格模式代码 because of a common non-standard language extension (see 9.2.8) that enables observation of the chain of caller contexts.

14.9.2静态语义: HasCallInTailPosition

With parameter call.

Note

call is a 解析节点 that represents a specific range of 源文本. When the following 算法 compare call to another 解析节点, it is a test of whether they represent the same 源文本.

14.9.2.1Statement Rules

Return HasCallInTailPosition of AssignmentExpression with argument call.

Let has be HasCallInTailPosition of StatementList with argument call.
If has is true, return true.
Return HasCallInTailPosition of StatementListItem with argument call.

[empty]

{

}

return

;

for

(

)

for

(

var

)

for

(

)

{

}

Return false.

(

)

else

Let has be HasCallInTailPosition of the first Statement with argument call.
If has is true, return true.
Return HasCallInTailPosition of the second Statement with argument call.

(

)

while

(

)

;

while

(

)

for

(

opt

;

opt

;

opt

)

for

(

var

;

opt

;

opt

)

for

(

opt

;

opt

)

for

(

)

for

(

var

)

for

(

)

with

(

)

Return HasCallInTailPosition of Statement with argument call.

Return HasCallInTailPosition of LabelledItem with argument call.

return

;

Return HasCallInTailPosition of Expression with argument call.

switch

(

)

Return HasCallInTailPosition of CaseBlock with argument call.

{

opt

opt

}

Let has be false.
If the first CaseClauses is present, let has be HasCallInTailPosition of the first CaseClauses with argument call.
If has is true, return true.
Let has be HasCallInTailPosition of the DefaultClause with argument call.
If has is true, return true.
If the second CaseClauses is present, let has be HasCallInTailPosition of the second CaseClauses with argument call.
Return has.

Let has be HasCallInTailPosition of CaseClauses with argument call.
If has is true, return true.
Return HasCallInTailPosition of CaseClause with argument call.

case

opt

default

opt

If StatementList is present, return HasCallInTailPosition of StatementList with argument call.
Return false.

try

Return HasCallInTailPosition of Catch with argument call.

try

try

Return HasCallInTailPosition of Finally with argument call.

catch

(

)

Return HasCallInTailPosition of Block with argument call.

14.9.2.2Expression Rules

Note

A potential tail position call that is immediately followed by return GetValue of the call result is also a possible tail position call. 函数调用 cannot return reference values, so such a GetValue operation will always return the same value as the actual function call result.

===

!==

instanceof

>>>

delete

void

typeof

[

]

new

[

]

new

this

Return false.

Return HasCallInTailPosition of AssignmentExpression with argument call.

Let has be HasCallInTailPosition of the first AssignmentExpression with argument call.
If has is true, return true.
Return HasCallInTailPosition of the second AssignmentExpression with argument call.

Return HasCallInTailPosition of BitwiseORExpression with argument call.

Return HasCallInTailPosition of LogicalANDExpression with argument call.

If this CallExpression is call, return true.
Return false.

If this MemberExpression is call, return true.
Return false.

Let expr be CoveredParenthesizedExpression of CoverParenthesizedExpressionAndArrowParameterList.
Return HasCallInTailPosition of expr with argument call.

(

)

Return HasCallInTailPosition of Expression with argument call.

14.9.3运行时语义: PrepareForTailCall ( )

The 抽象操作 PrepareForTailCall 执行如下:

Let leafContext be the 运行时执行上下文.
Suspend leafContext.
Pop leafContext from the 执行上下文堆栈. The 执行上下文 now on the top of the stack becomes the 运行时执行上下文.
Assert: leafContext has no further use. It will never be activated as the 运行时执行上下文.

A tail position call must either release any transient internal resources associated with the currently executing function 执行上下文 before invoking the target function or reuse those resources in support of the target function.

Note

例如, a tail position call should only grow an 实现's activation record stack by the amount that the size of the target function's activation record exceeds the size of the calling function's activation record. If the target function's activation record is smaller, then the total size of the stack should decrease.

15ES 语言：脚本和模块

15.1脚本

Syntax

opt

[~Yield, ~Await, ~Return]

15.1.1静态语义: 早期错误

Script

这是一个句法错误如果 the LexicallyDeclaredNames of ScriptBody contains any duplicate entries.
这是一个句法错误如果 any element of the LexicallyDeclaredNames of ScriptBody also occurs in the VarDeclaredNames of ScriptBody.

这是一个句法错误如果 StatementList Contains super unless the source code containing super is eval code that is being processed by a direct eval. Additional 早期错误 rules for super within direct eval are defined in 18.2.1.1.
这是一个句法错误如果 StatementList Contains NewTarget unless the source code containing NewTarget is eval code that is being processed by a direct eval. Additional 早期错误 rules for NewTarget in direct eval are defined in 18.2.1.1.
这是一个句法错误如果 ContainsDuplicateLabels of StatementList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedBreakTarget of StatementList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedContinueTarget of StatementList with arguments « » and « » is true.

15.1.2静态语义: IsStrict

If the Directive Prologue of StatementList contains a Use Strict Directive, return true; otherwise, return false.

15.1.3静态语义: LexicallyDeclaredNames

Return TopLevelLexicallyDeclaredNames of StatementList.

Note

At the top level of a Script, 函数声明 are treated like var declarations rather than like lexical declarations.

15.1.4静态语义: LexicallyScopedDeclarations

Return TopLevelLexicallyScopedDeclarations of StatementList.

15.1.5静态语义: VarDeclaredNames

Return TopLevelVarDeclaredNames of StatementList.

15.1.6静态语义: VarScopedDeclarations

Return TopLevelVarScopedDeclarations of StatementList.

15.1.7运行时语义: 估值

Script

[empty]

Return NormalCompletion(undefined).

15.1.8脚本记录

A 脚本记录 encapsulates information about a script being evaluated. Each 脚本记录 contains the fields listed in Table 36.

Table 36: 脚本记录 Fields

字段名	值类型	Meaning
[[Realm]]	Realm Record \| undefined	The realm within which this script was created. undefined if not yet assigned.
[[Environment]]	词法环境 \| undefined	The 词法环境 containing the top level bindings for this script. This field is set when the script is instantiated.
[[ECMAScriptCode]]	a 解析节点	The result of parsing the 源文本 of this module using Script as the 目标符.
[[HostDefined]]	Any, 默认值 is undefined.	Field reserved for use by 宿主环境 that need to associate additional information with a script.

15.1.9ParseScript ( `源文本`, `realm`, `hostDefined` )

The 抽象操作 ParseScript with arguments 源文本, realm, and hostDefined creates a 脚本记录 based upon the result of parsing 源文本 as a Script. ParseScript 执行如下:

Assert: 源文本 is an ES 源文本 (see clause 10).
Parse 源文本 using Script as the 目标符 and analyse the parse result for any 早期错误 conditions. If the parse was successful and no 早期错误 were found, let body be the resulting parse tree. Otherwise, let body be a List of one or more SyntaxError or ReferenceError objects representing the parsing errors and/or 早期错误. Parsing and 早期错误 detection may be interweaved in an 实现-dependent manner. If more than one 解析错误 or 早期错误 is present, the number and ordering of 错误对象 in the list is 实现-dependent, but at least one must be present.
If body is a List of errors, return body.
Return 脚本记录 {[[Realm]]: realm, [[Environment]]: undefined, [[ECMAScriptCode]]: body, [[HostDefined]]: hostDefined}.

Note

An 实现 may parse script 源文本 and analyse it for 早期错误 conditions prior to 估值 of ParseScript for that script 源文本. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseScript upon that 源文本.

15.1.10ScriptEvaluation ( `scriptRecord` )

Let globalEnv be scriptRecord.[[Realm]].[[GlobalEnv]].
Let scriptCxt be a new ES 代码执行上下文.
Set the Function of scriptCxt to null.
Set the Realm of scriptCxt to scriptRecord.[[Realm]].
Set the ScriptOrModule of scriptCxt to scriptRecord.
Set the VariableEnvironment of scriptCxt to globalEnv.
Set the LexicalEnvironment of scriptCxt to globalEnv.
Suspend the currently 运行时执行上下文.
Push scriptCxt on to the 执行上下文堆栈; scriptCxt is now the 运行时执行上下文.
Let scriptBody be scriptRecord.[[ECMAScriptCode]].
Let result be GlobalDeclarationInstantiation(scriptBody, globalEnv).
If result.[[Type]] is normal, then
1. Set result to the result of evaluating scriptBody.
If result.[[Type]] is normal and result.[[Value]] is empty, then
1. Set result to NormalCompletion(undefined).
Suspend scriptCxt and remove it from the 执行上下文堆栈.
Assert: The 执行上下文堆栈 is not empty.
Resume the context that is now on the top of the 执行上下文堆栈 as the 运行时执行上下文.
Return Completion(result).

15.1.11运行时语义: GlobalDeclarationInstantiation ( `script`, `env` )

Note 1

When an 执行上下文 is established for evaluating 脚本, declarations are instantiated in the current 全局环境. Each global binding declared in the code is instantiated.

GlobalDeclarationInstantiation is performed as follows using arguments script and env. script is the ScriptBody for which the 执行上下文 is being established. env is the global 词法环境 in which bindings are to be created.

Let envRec be env's EnvironmentRecord.
Assert: envRec is a global 环境记录.
Let lexNames be the LexicallyDeclaredNames of script.
Let varNames be the VarDeclaredNames of script.
For each name in lexNames, do
1. If envRec.HasVarDeclaration(name) is true, 抛出一个 SyntaxError 异常.
2. If envRec.HasLexicalDeclaration(name) is true, 抛出一个 SyntaxError 异常.
3. Let hasRestrictedGlobal be ? envRec.HasRestrictedGlobalProperty(name).
4. If hasRestrictedGlobal is true, 抛出一个 SyntaxError 异常.
For each name in varNames, do
1. If envRec.HasLexicalDeclaration(name) is true, 抛出一个 SyntaxError 异常.
Let varDeclarations be the VarScopedDeclarations of script.
Let functionsToInitialize be a new empty List.
Let declaredFunctionNames be a new empty List.
For each d in varDeclarations, in reverse list order, do
1. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
  1. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
  2. NOTE: If there are multiple 函数声明 for the same name, the last declaration is used.
  3. Let fn be the sole element of the 绑定名 of d.
  4. If fn is not an element of declaredFunctionNames, then
    1. Let fnDefinable be ? envRec.CanDeclareGlobalFunction(fn).
    2. If fnDefinable is false, 抛出一个 TypeError 异常.
    3. Append fn to declaredFunctionNames.
    4. Insert d as the first element of functionsToInitialize.
Let declaredVarNames be a new empty List.
For each d in varDeclarations, do
1. If d is a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
  1. For each String vn in the 绑定名 of d, do
    1. If vn is not an element of declaredFunctionNames, then
      1. Let vnDefinable be ? envRec.CanDeclareGlobalVar(vn).
      2. If vnDefinable is false, 抛出一个 TypeError 异常.
      3. If vn is not an element of declaredVarNames, then
        Append vn to declaredVarNames.
NOTE: No abnormal terminations occur after this 算法步骤 if the 全局对象 is an 普通对象. However, if the 全局对象 is a Proxy 外来对象 it may exhibit behaviours that cause abnormal terminations in some of the following steps.
NOTE: Annex B.3.3.2 adds additional steps at this point.
Let lexDeclarations be the LexicallyScopedDeclarations of script.
For each element d in lexDeclarations, do
1. NOTE: Lexically declared names are only instantiated here but not initialized.
2. For each element dn of the 绑定名 of d, do
  1. If IsConstantDeclaration of d is true, then
    1. Perform ? envRec.CreateImmutableBinding(dn, true).
  2. Else,
    1. Perform ? envRec.CreateMutableBinding(dn, false).
For each 解析节点 f in functionsToInitialize, do
1. Let fn be the sole element of the 绑定名 of f.
2. Let fo be the result of performing InstantiateFunctionObject for f with argument env.
3. Perform ? envRec.CreateGlobalFunctionBinding(fn, fo, false).
For each String vn in declaredVarNames, in list order, do
1. Perform ? envRec.CreateGlobalVarBinding(vn, false).
Return NormalCompletion(empty).

Note 2

早期错误 specified in 15.1.1 prevent name conflicts between function/var declarations and let/const/class declarations as well as redeclaration of let/const/class bindings for declaration contained within a single Script. However, such conflicts and redeclarations that span more than one Script are detected as runtime errors during GlobalDeclarationInstantiation. If any such errors are detected, no bindings are instantiated for the script. However, if the 全局对象 is defined using Proxy 外来对象 then the runtime tests for conflicting declarations may be unreliable resulting in an abrupt completion and some global declarations not being instantiated. If this occurs, the code for the Script is not evaluated.

Unlike explicit var or 函数声明, properties that are directly created on the 全局对象 result in global bindings that may be shadowed by let/const/class declarations.

15.1.12运行时语义: ScriptEvaluationJob ( `源文本`, `hostDefined` )

The job ScriptEvaluationJob with parameters 源文本 and hostDefined parses, validates, and evaluates 源文本 as a Script.

Assert: 源文本 is an ES 源文本 (see clause 10).
Let realm be the current Realm Record.
Let s be ParseScript(源文本, realm, hostDefined).
If s is a List of errors, then
1. Perform HostReportErrors(s).
2. Return NormalCompletion(undefined).
Return ? ScriptEvaluation(s).

15.2模块

Syntax

opt

[~Yield, ~Await, ~Return]

15.2.1模块语义

15.2.1.1静态语义: 早期错误

ModuleBody

这是一个句法错误如果 the LexicallyDeclaredNames of ModuleItemList contains any duplicate entries.
这是一个句法错误如果 any element of the LexicallyDeclaredNames of ModuleItemList also occurs in the VarDeclaredNames of ModuleItemList.
这是一个句法错误如果 the ExportedNames of ModuleItemList contains any duplicate entries.
这是一个句法错误如果 any element of the ExportedBindings of ModuleItemList does not also occur in either the VarDeclaredNames of ModuleItemList, or the LexicallyDeclaredNames of ModuleItemList.
这是一个句法错误如果 ModuleItemList Contains super.
这是一个句法错误如果 ModuleItemList Contains NewTarget.
这是一个句法错误如果 ContainsDuplicateLabels of ModuleItemList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedBreakTarget of ModuleItemList with argument « » is true.
这是一个句法错误如果 ContainsUndefinedContinueTarget of ModuleItemList with arguments « » and « » is true.

Note

The duplicate ExportedNames rule implies that multiple export default ExportDeclaration items within a ModuleBody is a Syntax Error. Additional error conditions relating to conflicting or duplicate declarations are checked during module linking prior to 估值 of a Module. If any such errors are detected the Module is not evaluated.

15.2.1.2静态语义: ContainsDuplicateLabels

With parameter labelSet.

Let hasDuplicates be ContainsDuplicateLabels of ModuleItemList with argument labelSet.
If hasDuplicates is true, return true.
Return ContainsDuplicateLabels of ModuleItem with argument labelSet.

Return false.

15.2.1.3静态语义: ContainsUndefinedBreakTarget

With parameter labelSet.

Let hasUndefinedLabels be ContainsUndefinedBreakTarget of ModuleItemList with argument labelSet.
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedBreakTarget of ModuleItem with argument labelSet.

Return false.

15.2.1.4静态语义: ContainsUndefinedContinueTarget

With parameters iterationSet and labelSet.

Let hasUndefinedLabels be ContainsUndefinedContinueTarget of ModuleItemList with arguments iterationSet and « ».
If hasUndefinedLabels is true, return true.
Return ContainsUndefinedContinueTarget of ModuleItem with arguments iterationSet and « ».

Return false.

15.2.1.5静态语义: ExportedBindings

Note

ExportedBindings are the locally bound names that are explicitly associated with a Module's ExportedNames.

Let names be ExportedBindings of ModuleItemList.
Append to names the elements of the ExportedBindings of ModuleItem.
Return names.

Return a new empty List.

15.2.1.6静态语义: ExportedNames

Note

ExportedNames are the externally visible names that a Module explicitly maps to one of its local name bindings.

Let names be ExportedNames of ModuleItemList.
Append to names the elements of the ExportedNames of ModuleItem.
Return names.

Return the ExportedNames of ExportDeclaration.

Return a new empty List.

15.2.1.7静态语义: ExportEntries

[empty]

Return a new empty List.

Let entries be ExportEntries of ModuleItemList.
Append to entries the elements of the ExportEntries of ModuleItem.
Return entries.

Return a new empty List.

15.2.1.8静态语义: ImportEntries

[empty]

Return a new empty List.

Let entries be ImportEntries of ModuleItemList.
Append to entries the elements of the ImportEntries of ModuleItem.
Return entries.

Return a new empty List.

15.2.1.9静态语义: ImportedLocalNames ( `importEntries` )

The 抽象操作 ImportedLocalNames with argument importEntries creates a List of all of the local name bindings defined by a List of ImportEntry Records (see Table 40). ImportedLocalNames 执行如下:

Let localNames be a new empty List.
For each ImportEntry Record i in importEntries, do
1. Append i.[[LocalName]] to localNames.
Return localNames.

15.2.1.10静态语义: ModuleRequests

[empty]

Return a new empty List.

Return ModuleRequests of ModuleItem.

Let moduleNames be ModuleRequests of ModuleItemList.
Let additionalNames be ModuleRequests of ModuleItem.
Append to moduleNames each element of additionalNames that is not already an element of moduleNames.
Return moduleNames.

Return a new empty List.

15.2.1.11静态语义: LexicallyDeclaredNames

Note 1

The LexicallyDeclaredNames of a Module includes the names of all of its imported bindings.

Let names be LexicallyDeclaredNames of ModuleItemList.
Append to names the elements of the LexicallyDeclaredNames of ModuleItem.
Return names.

Return the 绑定名 of ImportDeclaration.

If ExportDeclaration is export VariableStatement, return a new empty List.
Return the 绑定名 of ExportDeclaration.

Return LexicallyDeclaredNames of StatementListItem.

Note 2

At the top level of a Module, 函数声明 are treated like lexical declarations rather than like var declarations.

15.2.1.12静态语义: LexicallyScopedDeclarations

[empty]

Return a new empty List.

Let declarations be LexicallyScopedDeclarations of ModuleItemList.
Append to declarations the elements of the LexicallyScopedDeclarations of ModuleItem.
Return declarations.

Return a new empty List.

15.2.1.13静态语义: VarDeclaredNames

[empty]

Return a new empty List.

Let names be VarDeclaredNames of ModuleItemList.
Append to names the elements of the VarDeclaredNames of ModuleItem.
Return names.

Return a new empty List.

If ExportDeclaration is export VariableStatement, return 绑定名 of ExportDeclaration.
Return a new empty List.

15.2.1.14静态语义: VarScopedDeclarations

[empty]

Return a new empty List.

Let declarations be VarScopedDeclarations of ModuleItemList.
Append to declarations the elements of the VarScopedDeclarations of ModuleItem.
Return declarations.

Return a new empty List.

If ExportDeclaration is export VariableStatement, return VarScopedDeclarations of VariableStatement.
Return a new empty List.

15.2.1.15抽象模块记录

A Module Record encapsulates structural information about the imports and exports of a single module. This information is used to link the imports and exports of sets of connected 模块. A Module Record includes four fields that are only used when evaluating a module.

For specification purposes Module Record values are values of the Record 规范类型 and can be thought of as existing in a simple object-oriented hierarchy where Module Record is an abstract class with concrete subclasses. This specification only defines a single Module Record concrete subclass named 源文本 Module Record. Other specifications and implementations may define additional Module Record subclasses corresponding to alternative module definition facilities that they defined.

Module Record defines the fields listed in Table 37. All Module Definition subclasses include at least those fields. Module Record also defines the abstract method list in Table 38. All Module definition subclasses must provide concrete implementations of these abstract methods.

Table 37: Module Record Fields

字段名	值类型	Meaning
[[Realm]]	Realm Record \| undefined	The Realm within which this module was created. undefined if not yet assigned.
[[Environment]]	词法环境 \| undefined	The 词法环境 containing the top level bindings for this module. This field is set when the module is instantiated.
[[命名空间]]	Object \| undefined	The 模块命名空间对象 (26.3) if one has been created for this module. Otherwise undefined.
[[HostDefined]]	Any, 默认值 is undefined.	Field reserved for use by 宿主环境 that need to associate additional information with a module.

Table 38: Abstract Methods of Module Records

Method	Purpose
GetExportedNames(`exportStarSet`)	Return a list of all names that are either directly or indirectly exported from this module.
ResolveExport(`exportName`, `resolveSet`)	Return the binding of a name exported by this module. Bindings are represented by a ResolvedBinding Record, of the form {[[Module]]: Module Record, [[BindingName]]: String}. Return null if the name cannot be resolved, or `"ambiguous"` if multiple bindings were found. This operation must be idempotent if it completes normally. Each time it is called with a specific `exportName`, `resolveSet` pair as arguments it must return the same result.
Instantiate()	Prepare the module for 估值 by transitively resolving all module dependencies and creating a module 环境记录.
Evaluate()	If this module has already been evaluated successfully, return undefined; if it has already been evaluated unsuccessfully, throw the 异常 that was produced. Otherwise, transitively evaluate all module dependencies of this module and then evaluate this module. Instantiate must have completed successfully prior to invoking this method.

15.2.1.16源文本模块记录

A 源文本 Module Record is used to represent information about a module that was defined from ES 源文本 (10) that was parsed using the 目标符 Module. Its fields contain digested information about the names that are imported by the module and its concrete methods use this digest to link, instantiate, and evaluate the module.

A 源文本 Module Record can exist in a module graph with other subclasses of the abstract Module Record type. However, non-源文本模块记录 must not participate in dependency cycles with 源文本模块记录.

In addition to the fields, defined in Table 37, 源文本模块记录 have the additional fields listed in Table 39. Each of these fields is initially set in ParseModule.

Table 39: Additional Fields of 源文本模块记录

字段名	值类型	Meaning
[[ECMAScriptCode]]	a 解析节点	The result of parsing the 源文本 of this module using Module as the 目标符.
[[RequestedModules]]	List of String	A List of all the ModuleSpecifier strings used by the module represented by this record to request the importation of a module. The List is source code occurrence ordered.
[[ImportEntries]]	List of ImportEntry Records	A List of ImportEntry records derived from the code of this module.
[[LocalExportEntries]]	List of ExportEntry Records	A List of ExportEntry records derived from the code of this module that correspond to declarations that occur within the module.
[[IndirectExportEntries]]	List of ExportEntry Records	A List of ExportEntry records derived from the code of this module that correspond to reexported imports that occur within the module.
[[StarExportEntries]]	List of ExportEntry Records	A List of ExportEntry records derived from the code of this module that correspond to export * declarations that occur within the module.
[[Status]]	String	Initially `"uninstantiated"`. Transitions to `"instantiating"`, `"instantiated"`, `"evaluating"`, `"evaluated"` (in that order) as the module progresses throughout its lifecycle.
[[EvaluationError]]	An abrupt completion \| undefined	A completion of type throw representing the 异常 that occurred during 估值. undefined if no 异常 occurred or if [[Status]] is not `"evaluated"`.
[[DFSIndex]]	Integer \| undefined	Auxiliary field used during Instantiate and Evaluate only. If [[Status]] is `"instantiating"` or `"evaluating"`, this non-negative number records the point at which the module was first visited during the ongoing depth-first traversal of the dependency graph.
[[DFSAncestorIndex]]	Integer \| undefined	Auxiliary field used during Instantiate and Evaluate only. If [[Status]] is `"instantiating"` or `"evaluating"`, this is either the module's own [[DFSIndex]] or that of an "earlier" module in the same strongly connected component.

An ImportEntry Record is a Record that digests information about a single declarative import. Each ImportEntry Record has the fields defined in Table 40:

Table 40: ImportEntry Record Fields

字段名	值类型	Meaning
[[ModuleRequest]]	String	String 值 of the ModuleSpecifier of the ImportDeclaration.
[[ImportName]]	String	The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. The value `"*"` indicates that the import request is for the target module's 命名空间 object.
[[LocalName]]	String	The name that is used to locally access the imported value from within the importing module.

Note 1

Table 41 gives examples of ImportEntry records fields used to represent the syntactic import forms:

Table 41 (Informative): Import Forms Mappings to ImportEntry Records

Import Statement Form	[[ModuleRequest]]	[[ImportName]]	[[LocalName]]
`import v from "mod";`	`"mod"`	`"default"`	`"v"`
`import * as ns from "mod";`	`"mod"`	`"*"`	`"ns"`
`import {x} from "mod";`	`"mod"`	`"x"`	`"x"`
`import {x as v} from "mod";`	`"mod"`	`"x"`	`"v"`
`import "mod";`	An ImportEntry Record is not created.

An ExportEntry Record is a Record that digests information about a single declarative export. Each ExportEntry Record has the fields defined in Table 42:

Table 42: ExportEntry Record Fields

字段名	值类型	Meaning
[[ExportName]]	String	The name used to export this binding by this module.
[[ModuleRequest]]	String \| null	The String 值 of the ModuleSpecifier of the ExportDeclaration. null if the ExportDeclaration does not have a ModuleSpecifier.
[[ImportName]]	String \| null	The name under which the desired binding is exported by the module identified by [[ModuleRequest]]. null if the ExportDeclaration does not have a ModuleSpecifier. `"*"` indicates that the export request is for all exported bindings.
[[LocalName]]	String \| null	The name that is used to locally access the exported value from within the importing module. null if the exported value is not locally accessible from within the module.

Note 2

Table 43 gives examples of the ExportEntry record fields used to represent the syntactic export forms:

Table 43 (Informative): Export Forms Mappings to ExportEntry Records

Export Statement Form	[[ExportName]]	[[ModuleRequest]]	[[ImportName]]	[[LocalName]]
`export var v;`	`"v"`	null	null	`"v"`
`export default function f(){}`	`"default"`	null	null	`"f"`
`export default function(){}`	`"default"`	null	null	`"default"`
`export default 42;`	`"default"`	null	null	`"default"`
`export {x};`	`"x"`	null	null	`"x"`
`export {v as x};`	`"x"`	null	null	`"v"`
`export {x} from "mod";`	`"x"`	`"mod"`	`"x"`	null
`export {v as x} from "mod";`	`"x"`	`"mod"`	`"v"`	null
`export * from "mod";`	null	`"mod"`	`"*"`	null

The following definitions specify the required concrete methods and other 抽象操作 for 源文本模块记录

15.2.1.16.1ParseModule ( `源文本`, `realm`, `hostDefined` )

The 抽象操作 ParseModule with arguments 源文本, realm, and hostDefined creates a 源文本 Module Record based upon the result of parsing 源文本 as a Module. ParseModule 执行如下:

Assert: 源文本 is an ES 源文本 (see clause 10).
Parse 源文本 using Module as the 目标符 and analyse the parse result for any 早期错误 conditions. If the parse was successful and no 早期错误 were found, let body be the resulting parse tree. Otherwise, let body be a List of one or more SyntaxError or ReferenceError objects representing the parsing errors and/or 早期错误. Parsing and 早期错误 detection may be interweaved in an 实现-dependent manner. If more than one 解析错误 or 早期错误 is present, the number and ordering of 错误对象 in the list is 实现-dependent, but at least one must be present.
If body is a List of errors, return body.
Let requestedModules be the ModuleRequests of body.
Let importEntries be ImportEntries of body.
Let importedBoundNames be ImportedLocalNames(importEntries).
Let indirectExportEntries be a new empty List.
Let localExportEntries be a new empty List.
Let starExportEntries be a new empty List.
Let exportEntries be ExportEntries of body.
For each ExportEntry Record ee in exportEntries, do
1. If ee.[[ModuleRequest]] is null, then
  1. If ee.[[LocalName]] is not an element of importedBoundNames, then
    1. Append ee to localExportEntries.
  2. Else,
    1. Let ie be the element of importEntries whose [[LocalName]] is the same as ee.[[LocalName]].
    2. If ie.[[ImportName]] is "*", then
      1. Assert: This is a re-export of an imported 模块命名空间对象.
      2. Append ee to localExportEntries.
    3. Else this is a re-export of a single name,
      1. Append the ExportEntry Record {[[ModuleRequest]]: ie.[[ModuleRequest]], [[ImportName]]: ie.[[ImportName]], [[LocalName]]: null, [[ExportName]]: ee.[[ExportName]] } to indirectExportEntries.
2. Else if ee.[[ImportName]] is "*", then
  1. Append ee to starExportEntries.
3. Else,
  1. Append ee to indirectExportEntries.
Return 源文本 Module Record {[[Realm]]: realm, [[Environment]]: undefined, [[命名空间]]: undefined, [[Status]]: "uninstantiated", [[EvaluationError]]: undefined, [[HostDefined]]: hostDefined, [[ECMAScriptCode]]: body, [[RequestedModules]]: requestedModules, [[ImportEntries]]: importEntries, [[LocalExportEntries]]: localExportEntries, [[IndirectExportEntries]]: indirectExportEntries, [[StarExportEntries]]: starExportEntries, [[DFSIndex]]: undefined, [[DFSAncestorIndex]]: undefined}.

Note

An 实现 may parse module 源文本 and analyse it for 早期错误 conditions prior to the 估值 of ParseModule for that module 源文本. However, the reporting of any errors must be deferred until the point where this specification actually performs ParseModule upon that 源文本.

15.2.1.16.2GetExportedNames( `exportStarSet` ) Concrete Method

The GetExportedNames concrete method of a 源文本 Module Record implements the corresponding Module Record abstract method.

It 执行如下:

Let module be this 源文本 Module Record.
If exportStarSet contains module, then
1. Assert: We've reached the starting point of an import * circularity.
2. Return a new empty List.
Append module to exportStarSet.
Let exportedNames be a new empty List.
For each ExportEntry Record e in module.[[LocalExportEntries]], do
1. Assert: module provides the direct binding for this export.
2. Append e.[[ExportName]] to exportedNames.
For each ExportEntry Record e in module.[[IndirectExportEntries]], do
1. Assert: module imports a specific binding for this export.
2. Append e.[[ExportName]] to exportedNames.
For each ExportEntry Record e in module.[[StarExportEntries]], do
1. Let requestedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
2. Let starNames be ? requestedModule.GetExportedNames(exportStarSet).
3. For each element n of starNames, do
  1. If SameValue(n, "default") is false, then
    1. If n is not an element of exportedNames, then
      1. Append n to exportedNames.
Return exportedNames.

Note

GetExportedNames does not filter out or 抛出一个异常 for names that have ambiguous star export bindings.

15.2.1.16.3ResolveExport( `exportName`, `resolveSet` ) Concrete Method

The ResolveExport concrete method of a 源文本 Module Record implements the corresponding Module Record abstract method.

ResolveExport attempts to resolve an imported binding to the actual defining module and local binding name. The defining module may be the module represented by the Module Record this method was invoked on or some other module that is imported by that module. The parameter resolveSet is used to detect unresolved circular import/export paths. If a pair consisting of specific Module Record and exportName is reached that is already in resolveSet, an import circularity has been encountered. Before recursively calling ResolveExport, a pair consisting of module and exportName is added to resolveSet.

If a defining module is found, a ResolvedBinding Record {[[Module]], [[BindingName]]} is returned. This record identifies the resolved binding of the originally requested export. If no definition was found or the request is found to be circular, null is returned. If the request is found to be ambiguous, the string "ambiguous" is returned.

This abstract method 执行如下:

Let module be this 源文本 Module Record.
For each Record {[[Module]], [[ExportName]]} r in resolveSet, do
1. If module and r.[[Module]] are the same Module Record and SameValue(exportName, r.[[ExportName]]) is true, then
  1. Assert: This is a circular import request.
  2. Return null.
Append the Record {[[Module]]: module, [[ExportName]]: exportName} to resolveSet.
For each ExportEntry Record e in module.[[LocalExportEntries]], do
1. If SameValue(exportName, e.[[ExportName]]) is true, then
  1. Assert: module provides the direct binding for this export.
  2. Return ResolvedBinding Record {[[Module]]: module, [[BindingName]]: e.[[LocalName]]}.
For each ExportEntry Record e in module.[[IndirectExportEntries]], do
1. If SameValue(exportName, e.[[ExportName]]) is true, then
  1. Assert: module imports a specific binding for this export.
  2. Let importedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
  3. Return importedModule.ResolveExport(e.[[ImportName]], resolveSet).
If SameValue(exportName, "default") is true, then
1. Assert: A default export was not explicitly defined by this module.
2. Return null.
3. NOTE: A default export cannot be provided by an export *.
Let starResolution be null.
For each ExportEntry Record e in module.[[StarExportEntries]], do
1. Let importedModule be ? HostResolveImportedModule(module, e.[[ModuleRequest]]).
2. Let resolution be ? importedModule.ResolveExport(exportName, resolveSet).
3. If resolution is "ambiguous", return "ambiguous".
4. If resolution is not null, then
  1. Assert: resolution is a ResolvedBinding Record.
  2. If starResolution is null, set starResolution to resolution.
  3. Else,
    1. Assert: There is more than one * import that includes the requested name.
    2. If resolution.[[Module]] and starResolution.[[Module]] are not the same Module Record or SameValue(resolution.[[BindingName]], starResolution.[[BindingName]]) is false, return "ambiguous".
Return starResolution.

15.2.1.16.4Instantiate( ) Concrete Method

The Instantiate concrete method of a 源文本 Module Record implements the corresponding Module Record abstract method.

On success, Instantiate transitions this module's [[Status]] from "uninstantiated" to "instantiated". On failure, an 异常 is thrown and this module's [[Status]] remains "uninstantiated".

This abstract method 执行如下 (most of the work is done by the auxiliary function InnerModuleInstantiation):

Let module be this 源文本 Module Record.
Assert: module.[[Status]] is not "instantiating" or "evaluating".
Let stack be a new empty List.
Let result be InnerModuleInstantiation(module, stack, 0).
If result is an abrupt completion, then
1. For each module m in stack, do
  1. Assert: m.[[Status]] is "instantiating".
  2. Set m.[[Status]] to "uninstantiated".
  3. Set m.[[Environment]] to undefined.
  4. Set m.[[DFSIndex]] to undefined.
  5. Set m.[[DFSAncestorIndex]] to undefined.
2. Assert: module.[[Status]] is "uninstantiated".
3. Return result.
Assert: module.[[Status]] is "instantiated" or "evaluated".
Assert: stack is empty.
Return undefined.

15.2.1.16.4.1InnerModuleInstantiation( `module`, `stack`, `index` )

The InnerModuleInstantiation 抽象操作 is used by Instantiate to perform the actual instantiation process for the 源文本 Module Record module, as well as recursively on all other 模块 in the dependency graph. The stack and index parameters, as well as a module's [[DFSIndex]] and [[DFSAncestorIndex]] fields, keep track of the depth-first search (DFS) traversal. In particular, [[DFSAncestorIndex]] is used to discover strongly connected components (SCCs), such that all 模块 in an SCC transition to "instantiated" together.

This 抽象操作执行如下:

If module is not a 源文本 Module Record, then
1. Perform ? module.Instantiate().
2. Return index.
If module.[[Status]] is "instantiating", "instantiated", or "evaluated", then
1. Return index.
Assert: module.[[Status]] is "uninstantiated".
Set module.[[Status]] to "instantiating".
Set module.[[DFSIndex]] to index.
Set module.[[DFSAncestorIndex]] to index.
Set index to index + 1.
Append module to stack.
For each String required that is an element of module.[[RequestedModules]], do
1. Let requiredModule be ? HostResolveImportedModule(module, required).
2. Set index to ? InnerModuleInstantiation(requiredModule, stack, index).
3. Assert: requiredModule.[[Status]] is either "instantiating", "instantiated", or "evaluated".
4. Assert: requiredModule.[[Status]] is "instantiating" if and only if requiredModule is in stack.
5. If requiredModule.[[Status]] is "instantiating", then
  1. Assert: requiredModule is a 源文本 Module Record.
  2. Set module.[[DFSAncestorIndex]] to min(module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]]).
Perform ? ModuleDeclarationEnvironmentSetup(module).
Assert: module occurs exactly once in stack.
Assert: module.[[DFSAncestorIndex]] is less than or equal to module.[[DFSIndex]].
If module.[[DFSAncestorIndex]] equals module.[[DFSIndex]], then
1. Let done be false.
2. Repeat, while done is false,
  1. Let requiredModule be the last element in stack.
  2. Remove the last element of stack.
  3. Set requiredModule.[[Status]] to "instantiated".
  4. If requiredModule and module are the same Module Record, set done to true.
Return index.

15.2.1.16.4.2ModuleDeclarationEnvironmentSetup( `module` )

The ModuleDeclarationEnvironmentSetup 抽象操作 is used by InnerModuleInstantiation to initialize the 词法环境 of the module, including resolving all imported bindings.

This 抽象操作执行如下:

For each ExportEntry Record e in module.[[IndirectExportEntries]], do
1. Let resolution be ? module.ResolveExport(e.[[ExportName]], « »).
2. If resolution is null or "ambiguous", 抛出一个 SyntaxError 异常.
3. Assert: resolution is a ResolvedBinding Record.
Assert: All named exports from module are resolvable.
Let realm be module.[[Realm]].
Assert: realm is not undefined.
Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
Set module.[[Environment]] to env.
Let envRec be env's EnvironmentRecord.
For each ImportEntry Record in in module.[[ImportEntries]], do
1. Let importedModule be ! HostResolveImportedModule(module, in.[[ModuleRequest]]).
2. NOTE: The above call cannot fail because imported module requests are a subset of module.[[RequestedModules]], and these have been resolved earlier in this 算法.
3. If in.[[ImportName]] is "*", then
  1. Let 命名空间 be ? GetModuleNamespace(importedModule).
  2. Perform ! envRec.CreateImmutableBinding(in.[[LocalName]], true).
  3. Call envRec.InitializeBinding(in.[[LocalName]], 命名空间).
4. Else,
  1. Let resolution be ? importedModule.ResolveExport(in.[[ImportName]], « »).
  2. If resolution is null or "ambiguous", 抛出一个 SyntaxError 异常.
  3. Call envRec.CreateImportBinding(in.[[LocalName]], resolution.[[Module]], resolution.[[BindingName]]).
Let code be module.[[ECMAScriptCode]].
Let varDeclarations be the VarScopedDeclarations of code.
Let declaredVarNames be a new empty List.
For each element d in varDeclarations, do
1. For each element dn of the 绑定名 of d, do
  1. If dn is not an element of declaredVarNames, then
    1. Perform ! envRec.CreateMutableBinding(dn, false).
    2. Call envRec.InitializeBinding(dn, undefined).
    3. Append dn to declaredVarNames.
Let lexDeclarations be the LexicallyScopedDeclarations of code.
For each element d in lexDeclarations, do
1. For each element dn of the 绑定名 of d, do
  1. If IsConstantDeclaration of d is true, then
    1. Perform ! envRec.CreateImmutableBinding(dn, true).
  2. Else,
    1. Perform ! envRec.CreateMutableBinding(dn, false).
  3. If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
    1. Let fo be the result of performing InstantiateFunctionObject for d with argument env.
    2. Call envRec.InitializeBinding(dn, fo).

15.2.1.16.5Evaluate( ) Concrete Method

The Evaluate concrete method of a 源文本 Module Record implements the corresponding Module Record abstract method.

Evaluate transitions this module's [[Status]] from "instantiated" to "evaluated".

If execution results in an 异常, that 异常 is recorded in the [[EvaluationError]] field and rethrown by future invocations of Evaluate.

This abstract method 执行如下 (most of the work is done by the auxiliary function InnerModuleEvaluation):

Let module be this 源文本 Module Record.
Assert: module.[[Status]] is "instantiated" or "evaluated".
Let stack be a new empty List.
Let result be InnerModuleEvaluation(module, stack, 0).
If result is an abrupt completion, then
1. For each module m in stack, do
  1. Assert: m.[[Status]] is "evaluating".
  2. Set m.[[Status]] to "evaluated".
  3. Set m.[[EvaluationError]] to result.
2. Assert: module.[[Status]] is "evaluated" and module.[[EvaluationError]] is result.
3. Return result.
Assert: module.[[Status]] is "evaluated" and module.[[EvaluationError]] is undefined.
Assert: stack is empty.
Return undefined.

15.2.1.16.5.1InnerModuleEvaluation( `module`, `stack`, `index` )

The InnerModuleEvaluation 抽象操作 is used by Evaluate to perform the actual 估值 process for the 源文本 Module Record module, as well as recursively on all other 模块 in the dependency graph. The stack and index parameters, as well as module's [[DFSIndex]] and [[DFSAncestoreIndex]] fields, are used the same way as in InnerModuleInstantiation.

This 抽象操作执行如下:

If module is not a 源文本 Module Record, then
1. Perform ? module.Evaluate().
2. Return index.
If module.[[Status]] is "evaluated", then
1. If module.[[EvaluationError]] is undefined, return index.
2. Otherwise return module.[[EvaluationError]].
If module.[[Status]] is "evaluating", return index.
Assert: module.[[Status]] is "instantiated".
Set module.[[Status]] to "evaluating".
Set module.[[DFSIndex]] to index.
Set module.[[DFSAncestorIndex]] to index.
Set index to index + 1.
Append module to stack.
For each String required that is an element of module.[[RequestedModules]], do
1. Let requiredModule be ! HostResolveImportedModule(module, required).
2. NOTE: Instantiate must be completed successfully prior to invoking this method, so every requested module is guaranteed to resolve successfully.
3. Set index to ? InnerModuleEvaluation(requiredModule, stack, index).
4. Assert: requiredModule.[[Status]] is either "evaluating" or "evaluated".
5. Assert: requiredModule.[[Status]] is "evaluating" if and only if requiredModule is in stack.
6. If requiredModule.[[Status]] is "evaluating", then
  1. Assert: requiredModule is a 源文本 Module Record.
  2. Set module.[[DFSAncestorIndex]] to min(module.[[DFSAncestorIndex]], requiredModule.[[DFSAncestorIndex]]).
Perform ? ModuleExecution(module).
Assert: module occurs exactly once in stack.
Assert: module.[[DFSAncestorIndex]] is less than or equal to module.[[DFSIndex]].
If module.[[DFSAncestorIndex]] equals module.[[DFSIndex]], then
1. Let done be false.
2. Repeat, while done is false,
  1. Let requiredModule be the last element in stack.
  2. Remove the last element of stack.
  3. Set requiredModule.[[Status]] to "evaluated".
  4. If requiredModule and module are the same Module Record, set done to true.
Return index.

15.2.1.16.5.2ModuleExecution( `module` )

The ModuleExecution 抽象操作 is used by InnerModuleEvaluation to initialize the 执行上下文 of the module and evaluate the module's code within it.

This 抽象操作执行如下:

Let moduleCxt be a new ES 代码执行上下文.
Set the Function of moduleCxt to null.
Assert: module.[[Realm]] is not undefined.
Set the Realm of moduleCxt to module.[[Realm]].
Set the ScriptOrModule of moduleCxt to module.
Assert: module has been linked and declarations in its module environment have been instantiated.
Set the VariableEnvironment of moduleCxt to module.[[Environment]].
Set the LexicalEnvironment of moduleCxt to module.[[Environment]].
Suspend the currently 运行时执行上下文.
Push moduleCxt on to the 执行上下文堆栈; moduleCxt is now the 运行时执行上下文.
Let result be the result of evaluating module.[[ECMAScriptCode]].
Suspend moduleCxt and remove it from the 执行上下文堆栈.
Resume the context that is now on the top of the 执行上下文堆栈 as the 运行时执行上下文.
Return Completion(result).

15.2.1.16.6Example 源文本 Module Record Graphs

This non-normative section gives a series of examples of the instantiation and 估值 of a few common module graphs, with a specific focus on how errors can occur.

First consider the following simple module graph:

A module graph in which module A depends on module B — Figure 2: A simple module graph

Let's first assume that there are no error conditions. When a host first calls A.Instantiate(), this will complete successfully by assumption, and recursively instantiate 模块 B and C as well, such that A.[[Status]] = B.[[Status]] = C.[[Status]] = "instantiated". This preparatory step can be performed at any time. Later, when the host is ready to incur any possible side effects of the 模块, it can call A.Evaluate(), which will complete successfully (again by assumption), recursively having evaluated first C and then B. Each module's [[Status]] at this point will be "evaluated".

Consider then cases involving instantiation errors. If InnerModuleInstantiation of C succeeds but, thereafter, fails for B, 例如 because it imports something that C does not provide, then the original A.Instantiate() will fail, and both A and B's [[Status]] remain "uninstantiated". C's [[Status]] has become "instantiated", though.

Finally, consider a case involving 估值 errors. If InnerModuleEvaluation of C succeeds but, thereafter, fails for B, 例如 because B contains code that throws an 异常, then the original A.Evaluate() will fail. The resulting 异常 will be recorded in both A and B's [[EvaluationError]] fields, and their [[Status]] will become "evaluated". C will also become "evaluated" but, in contrast to A and B, will remain without an [[EvaluationError]], as it successfully completed 估值. Storing the 异常 ensures that any time a host tries to reuse A or B by calling their Evaluate() method, it will encounter the same 异常. (Hosts are not required to reuse 源文本模块记录; similarly, hosts are not required to expose the 异常 objects thrown by these methods. However, the specification enables such uses.)

The difference here between instantiation and 估值 errors is due to how 估值 must be only performed once, as it can cause side effects; it is thus important to remember whether 估值 has already been performed, even if unsuccessfully. (In the error case, it makes sense to also remember the 异常 because otherwise subsequent Evaluate() calls would have to synthesize a new one.) Instantiation, on the other hand, is side-effect-free, and thus even if it fails, it can be retried at a later time with no issues.

Now consider a different type of error condition:

A module graph in which module A depends on a missing (unresolvable) module, represented by ??? — Figure 3: A module graph with an unresolvable module

In this scenario, module A declares a dependency on some other module, but no Module Record exists for that module, i.e. HostResolveImportedModule throws an 异常 when asked for it. This could occur for a variety of reasons, 例如 the corresponding resource not existing, or the resource existing but ParseModule throwing an 异常 when trying to parse the resulting 源文本. Hosts can choose to expose the cause of failure via the 异常 they throw from HostResolveImportedModule. In any case, this 异常 causes an instantiation failure, which as before results in A's [[Status]] remaining "uninstantiated".

Lastly, consider a module graph with a cycle:

A module graph in which module A depends on module B and C, but module B also depends on module A — Figure 4: A cyclic module graph

Here we assume that the entry point is module A, so that the host proceeds by calling A.Instantiate(), which performs InnerModuleInstantiation on A. This in turn calls InnerModuleInstantiation on B. Because of the cycle, this again triggers InnerModuleInstantiation on A, but at this point it is a no-op since A.[[Status]] is already "instantiating". B.[[Status]] itself remains "instantiating" when control gets back to A and InnerModuleInstantiation is triggered on C. After this returns with C.[[Status]] being "instantiated" , both A and B transition from "instantiating" to "instantiated" together; this is by design, since they form a strongly connected component.

An analogous story occurs for the 估值 phase of a cyclic module graph, in the success case.

Now consider a case where A has an instantiation error; 例如, it tries to import a binding from C that does not exist. In that case, the above steps still occur, including the early return from the second call to InnerModuleInstantiation on A. However, once we unwind back to the original InnerModuleInstantiation on A, it fails during ModuleDeclarationEnvironmentSetup, namely right after C.ResolveExport(). The thrown **SyntaxError** 异常 propagates up to A.Instantiate, which resets all 模块 that are currently on its stack (these are always exactly the 模块 that are still "instantiating"). Hence both A and B become "uninstantiated". Note that C is left as "instantiated".

Finally, consider a case where A has an 估值 error; 例如, its source code throws an 异常. In that case, the 估值-time analog of the above steps still occurs, including the early return from the second call to InnerModuleEvaluation on A. However, once we unwind back to the original InnerModuleEvaluation on A, it fails by assumption. The 异常 thrown propagates up to A.Evaluate(), which records the error in all 模块 that are currently on its stack (i.e., the 模块 that are still "evaluating"). Hence both A and B become "errored", while C is left as "evaluated".

15.2.1.17运行时语义: HostResolveImportedModule ( `referencingModule`, `specifier` )

HostResolveImportedModule is an 实现-defined 抽象操作 that provides the concrete Module Record subclass instance that corresponds to the ModuleSpecifier String, specifier, occurring within the context of the module represented by the Module Record referencingModule.

The 实现 of HostResolveImportedModule must conform to the following requirements:

The normal 返回值 must be an instance of a concrete subclass of Module Record.
If a Module Record corresponding to the pair referencingModule, specifier does not exist or cannot be created, an 异常 must be thrown.
This operation must be idempotent if it completes normally. Each time it is called with a specific referencingModule, specifier pair as arguments it must return the same Module Record instance.

Multiple different referencingModule, specifier pairs may map to the same Module Record instance. The actual mapping semantic is 实现-defined but typically a normalization process is applied to specifier as part of the mapping process. A typical normalization process would include actions 例如 alphabetic case folding and expansion of relative and abbreviated path specifiers.

15.2.1.18运行时语义: GetModuleNamespace( `module` )

The GetModuleNamespace 抽象操作 retrieves the the Module 命名空间外来对象 representing module's exports, lazily creating it the first time it was requested, and storing it in module.[[命名空间]] for future retrieval.

This 抽象操作执行如下:

Assert: module is an instance of a concrete subclass of Module Record.
Assert: module.[[Status]] is not "uninstantiated".
Assert: If module.[[Status]] is "evaluated", module.[[EvaluationError]] is undefined.
Let 命名空间 be module.[[命名空间]].
If 命名空间 is undefined, then
1. Let exportedNames be ? module.GetExportedNames(« »).
2. Let unambiguousNames be a new empty List.
3. For each name that is an element of exportedNames, do
  1. Let resolution be ? module.ResolveExport(name, « »).
  2. If resolution is a ResolvedBinding Record, append name to unambiguousNames.
4. Set 命名空间 to ModuleNamespaceCreate(module, unambiguousNames).
Return 命名空间.

Note

The only way GetModuleNamespace can throw is via one of the triggered HostResolveImportedModule calls. Unresolvable names are simply excluded from the 命名空间 at this point. They will lead to a real instantiation error later unless they are all ambiguous star exports that are not explicitly requested anywhere.

15.2.1.19运行时语义: TopLevelModuleEvaluationJob ( `源文本`, `hostDefined` )

A TopLevelModuleEvaluationJob with parameters 源文本 and hostDefined is a job that parses, validates, and evaluates 源文本 as a Module.

Assert: 源文本 is an ES 源文本 (see clause 10).
Let realm be the current Realm Record.
Let m be ParseModule(源文本, realm, hostDefined).
If m is a List of errors, then
1. Perform HostReportErrors(m).
2. Return NormalCompletion(undefined).
Perform ? m.Instantiate().
Assert: All dependencies of m have been transitively resolved and m is ready for 估值.
Return ? m.Evaluate().

Note

An 实现 may parse a 源文本 as a Module, analyse it for 早期错误 conditions, and instantiate it prior to the execution of the TopLevelModuleEvaluationJob for that 源文本. An 实现 may also resolve, pre-parse and pre-analyse, and pre-instantiate module dependencies of 源文本. However, the reporting of any errors detected by these actions must be deferred until the TopLevelModuleEvaluationJob is actually executed.

15.2.1.20运行时语义: 估值

[empty]

Return NormalCompletion(undefined).

ModuleBody

Let result be the result of evaluating ModuleItemList.
If result.[[Type]] is normal and result.[[Value]] is empty, then
1. Return NormalCompletion(undefined).
Return Completion(result).

Let sl be the result of evaluating ModuleItemList.
ReturnIfAbrupt(sl).
Let s be the result of evaluating ModuleItem.
Return Completion(UpdateEmpty(s, sl.[[Value]])).

Note

The value of a ModuleItemList is the value of the last value-producing item in the ModuleItemList.

Return NormalCompletion(empty).

15.2.2Imports

Syntax

import

;

import

;

{

}

{

}

{

}

from

[~Yield, ~Await]

15.2.2.1静态语义: 早期错误

这是一个句法错误如果 the 绑定名 of ImportDeclaration contains any duplicate entries.

15.2.2.2静态语义: 绑定名

import

;

Return the 绑定名 of ImportClause.

import

;

Return a new empty List.

Let names be the 绑定名 of ImportedDefaultBinding.
Append to names the elements of the 绑定名 of NameSpaceImport.
Return names.

Let names be the 绑定名 of ImportedDefaultBinding.
Append to names the elements of the 绑定名 of NamedImports.
Return names.

{

}

Return a new empty List.

Let names be the 绑定名 of ImportsList.
Append to names the elements of the 绑定名 of ImportSpecifier.
Return names.

Return the 绑定名 of ImportedBinding.

15.2.2.3静态语义: ImportEntries

import

;

Let module be the sole element of ModuleRequests of FromClause.
Return ImportEntriesForModule of ImportClause with argument module.

import

;

Return a new empty List.

15.2.2.4静态语义: ImportEntriesForModule

With parameter module.

Let entries be ImportEntriesForModule of ImportedDefaultBinding with argument module.
Append to entries the elements of the ImportEntriesForModule of NameSpaceImport with argument module.
Return entries.

Let entries be ImportEntriesForModule of ImportedDefaultBinding with argument module.
Append to entries the elements of the ImportEntriesForModule of NamedImports with argument module.
Return entries.

Let localName be the sole element of 绑定名 of ImportedBinding.
Let defaultEntry be the ImportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: "default", [[LocalName]]: localName }.
Return a new List containing defaultEntry.

Let localName be the 字符值 of ImportedBinding.
Let entry be the ImportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: "*", [[LocalName]]: localName }.
Return a new List containing entry.

{

}

Return a new empty List.

Let specs be the ImportEntriesForModule of ImportsList with argument module.
Append to specs the elements of the ImportEntriesForModule of ImportSpecifier with argument module.
Return specs.

Let localName be the sole element of 绑定名 of ImportedBinding.
Let entry be the ImportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: localName, [[LocalName]]: localName }.
Return a new List containing entry.

Let importName be the 字符值 of IdentifierName.
Let localName be the 字符值 of ImportedBinding.
Let entry be the ImportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName }.
Return a new List containing entry.

15.2.2.5静态语义: ModuleRequests

import

;

Return ModuleRequests of FromClause.

Return a List containing the 字符值 of StringLiteral.

15.2.3Exports

Syntax

export

;

export

;

export

;

export

[~Yield, ~Await]

export

[~Yield, ~Await]

export

default

[~Yield, ~Await, +Default]

export

default

[~Yield, ~Await, +Default]

export

default

[lookahead ∉ { function, async

[no LineTerminator here]

function, class }]

[+In, ~Yield, ~Await]

;

{

}

{

}

{

}

15.2.3.1静态语义: 早期错误

export

;

For each IdentifierName n in ReferencedBindings of ExportClause: 这是一个句法错误如果字符值 of n is a ReservedWord or if the 字符值 of n is one of: "implements", "interface", "let", "package", "private", "protected", "public", or "static".

Note

The above rule means that each ReferencedBindings of ExportClause is treated as an IdentifierReference.

15.2.3.2静态语义: 绑定名

export

;

export

;

export

;

Return a new empty List.

export

Return the 绑定名 of VariableStatement.

export

Return the 绑定名 of Declaration.

export

default

Let declarationNames be the 绑定名 of HoistableDeclaration.
If declarationNames does not include the element "*default*", append "*default*" to declarationNames.
Return declarationNames.

export

default

Let declarationNames be the 绑定名 of ClassDeclaration.
If declarationNames does not include the element "*default*", append "*default*" to declarationNames.
Return declarationNames.

export

default

;

Return « "*default*" ».

15.2.3.3静态语义: ExportedBindings

export

;

export

;

Return a new empty List.

export

;

Return the ExportedBindings of ExportClause.

export

Return the 绑定名 of VariableStatement.

export

Return the 绑定名 of Declaration.

export

default

export

default

export

default

;

Return the 绑定名 of this ExportDeclaration.

{

}

Return a new empty List.

Let names be the ExportedBindings of ExportsList.
Append to names the elements of the ExportedBindings of ExportSpecifier.
Return names.

Return a List containing the 字符值 of IdentifierName.

Return a List containing the 字符值 of the first IdentifierName.

15.2.3.4静态语义: ExportedNames

export

;

Return a new empty List.

export

;

export

;

Return the ExportedNames of ExportClause.

export

Return the 绑定名 of VariableStatement.

export

Return the 绑定名 of Declaration.

export

default

export

default

export

default

;

Return « "default" ».

{

}

Return a new empty List.

Let names be the ExportedNames of ExportsList.
Append to names the elements of the ExportedNames of ExportSpecifier.
Return names.

Return a List containing the 字符值 of IdentifierName.

Return a List containing the 字符值 of the second IdentifierName.

15.2.3.5静态语义: ExportEntries

export

;

Let module be the sole element of ModuleRequests of FromClause.
Let entry be the ExportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: "*", [[LocalName]]: null, [[ExportName]]: null }.
Return a new List containing entry.

export

;

Let module be the sole element of ModuleRequests of FromClause.
Return ExportEntriesForModule of ExportClause with argument module.

export

;

Return ExportEntriesForModule of ExportClause with argument null.

export

Let entries be a new empty List.
Let names be the 绑定名 of VariableStatement.
For each name in names, do
1. Append the ExportEntry Record {[[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name } to entries.
Return entries.

export

Let entries be a new empty List.
Let names be the 绑定名 of Declaration.
For each name in names, do
1. Append the ExportEntry Record {[[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: name, [[ExportName]]: name } to entries.
Return entries.

export

default

Let names be 绑定名 of HoistableDeclaration.
Let localName be the sole element of names.
Return a new List containing the ExportEntry Record {[[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default"}.

export

default

Let names be 绑定名 of ClassDeclaration.
Let localName be the sole element of names.
Return a new List containing the ExportEntry Record {[[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default"}.

export

default

;

Let entry be the ExportEntry Record {[[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: "*default*", [[ExportName]]: "default"}.
Return a new List containing entry.

Note

"*default*" is used within this specification as a synthetic name for anonymous default export values.

15.2.3.6静态语义: ExportEntriesForModule

With parameter module.

{

}

Return a new empty List.

Let specs be the ExportEntriesForModule of ExportsList with argument module.
Append to specs the elements of the ExportEntriesForModule of ExportSpecifier with argument module.
Return specs.

Let sourceName be the 字符值 of IdentifierName.
If module is null, then
1. Let localName be sourceName.
2. Let importName be null.
Else,
1. Let localName be null.
2. Let importName be sourceName.
Return a new List containing the ExportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: sourceName }.

Let sourceName be the 字符值 of the first IdentifierName.
Let exportName be the 字符值 of the second IdentifierName.
If module is null, then
1. Let localName be sourceName.
2. Let importName be null.
Else,
1. Let localName be null.
2. Let importName be sourceName.
Return a new List containing the ExportEntry Record {[[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: exportName }.

15.2.3.7静态语义: IsConstantDeclaration

export

;

export

;

export

;

export

default

;

Return false.

Note

It is not necessary to treat export default AssignmentExpression as a constant declaration because there is no syntax that permits assignment to the internal bound name used to reference a module's default object.

15.2.3.8静态语义: LexicallyScopedDeclarations

export

;

export

;

export

;

export

Return a new empty List.

export

Return a new List containing DeclarationPart of Declaration.

export

default

Return a new List containing DeclarationPart of HoistableDeclaration.

export

default

Return a new List containing ClassDeclaration.

export

default

;

Return a new List containing this ExportDeclaration.

15.2.3.9静态语义: ModuleRequests

export

;

export

;

Return the ModuleRequests of FromClause.

export

;

export

export

export

default

export

default

export

default

;

Return a new empty List.

15.2.3.10静态语义: ReferencedBindings

{

}

Return a new empty List.

Let names be the ReferencedBindings of ExportsList.
Append to names the elements of the ReferencedBindings of ExportSpecifier.
Return names.

Return a List containing the IdentifierName.

Return a List containing the first IdentifierName.

15.2.3.11运行时语义: 估值

export

;

export

;

export

;

Return NormalCompletion(empty).

export

Return the result of evaluating VariableStatement.

export

Return the result of evaluating Declaration.

export

default

Return the result of evaluating HoistableDeclaration.

export

default

Let value be the result of BindingClassDeclarationEvaluation of ClassDeclaration.
ReturnIfAbrupt(value).
Let className be the sole element of 绑定名 of ClassDeclaration.
If className is "*default*", then
1. Let hasNameProperty be ? HasOwnProperty(value, "name").
2. If hasNameProperty is false, perform SetFunctionName(value, "default").
3. Let env be the 运行时执行上下文's LexicalEnvironment.
4. Perform ? InitializeBoundName("*default*", value, env).
Return NormalCompletion(empty).

export

default

;

Let rhs be the result of evaluating AssignmentExpression.
Let value be ? GetValue(rhs).
If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
1. Let hasNameProperty be ? HasOwnProperty(value, "name").
2. If hasNameProperty is false, perform SetFunctionName(value, "default").
Let env be the 运行时执行上下文's LexicalEnvironment.
Perform ? InitializeBoundName("*default*", value, env).
Return NormalCompletion(empty).

16错误处理与语言扩展

An 实现 must report most errors at the time the relevant ES language construct is evaluated. An 早期错误 is an error that can be detected and reported prior to the 估值 of any construct in the Script containing the error. The presence of an 早期错误 prevents the 估值 of the construct. An 实现 must report 早期错误 in a Script as part of parsing that Script in ParseScript. 早期错误 in a Module are reported at the point when the Module would be evaluated and the Module is never initialized. 早期错误 in eval code are reported at the time eval is called and prevent 估值 of the eval code. All errors that are not 早期错误 are runtime errors.

An 实现 must report as an 早期错误 any occurrence of a condition that is listed in a “静态语义: 早期错误” subclause of this specification.

An 实现 shall not treat other kinds of errors as 早期错误 even if the compiler can prove that a construct cannot execute without error under any circumstances. An 实现 may issue an early warning in such a case, but it should not report the error until the relevant construct is actually executed.

An 实现 shall report all errors as specified, except for the following:

Except as restricted in 16.2, an 实现 may extend Script syntax, Module syntax, and 正则表达式 pattern or flag syntax. To permit this, all operations (例如 calling eval, using a 正则表达式 literal, or using the Function or RegExp 构造器) that are allowed to throw SyntaxError are permitted to exhibit 实现-defined behaviour instead of throwing SyntaxError when they encounter an 实现-defined extension to the script syntax or 正则表达式 pattern or flag syntax.
Except as restricted in 16.2, an 实现 may provide additional types, values, objects, properties, and functions beyond those described 在本规范中. This may cause constructs (例如 looking up a variable in the global scope) to have 实现-defined behaviour instead of throwing an error (例如 ReferenceError).

16.1HostReportErrors ( `errorList` )

HostReportErrors is an 实现-defined 抽象操作 that allows 宿主环境 to report parsing errors, 早期错误, and runtime errors.

An 实现 of HostReportErrors must complete normally in all cases. The default 实现 of HostReportErrors is to unconditionally return an empty normal completion.

Note

errorList will be a List of ES 语言值. If the errors are parsing errors or 早期错误, these will always be SyntaxError or ReferenceError objects. Runtime errors, however, can be any ES 值.

16.2禁止扩展

An 实现 must not extend this specification in the following ways:

ES 函数对象 defined using syntactic constructors in 严格模式代码 must not be created with 自身属性 named "caller" or "arguments". Such 自身属性 also must not be created for 函数对象 defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in 严格模式代码. 内置 functions, strict functions created using the Function 构造器, generator functions created using the Generator 构造器, async functions created using the AsyncFunction 构造器, and functions created using the bind method also must not be created with such 自身属性.
If an 实现 extends any 函数对象 with an 自身属性 named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an 访问器属性, the function that is the value of the property's [[Get]] 特性 must never return a strict function when called.
Neither mapped nor unmapped arguments objects may be created with an 自身属性 named "caller".
The behaviour of the following methods must not be extended except as specified in ECMA-402: Object.prototype.toLocaleString, Array.prototype.toLocaleString, Number.prototype.toLocaleString, Date.prototype.toLocaleDateString, Date.prototype.toLocaleString, Date.prototype.toLocaleTimeString, String.prototype.localeCompare, %TypedArray%.prototype.toLocaleString.
The RegExp pattern grammars in 21.2.1 and B.1.4 must not be extended to recognize any of the source characters A-Z or a-z as IdentityEscape[+U] when the _[U] grammar parameter is present.
句法 must not be extended in any manner that allows the token : to immediately follow 源文本 that matches the BindingIdentifier 非终止符.
When processing 严格模式代码, the syntax of NumericLiteral must not be extended to include LegacyOctalIntegerLiteral and the syntax of DecimalIntegerLiteral must not be extended to include NonOctalDecimalIntegerLiteral as described in B.1.1.
TemplateCharacter must not be extended to include LegacyOctalEscapeSequence as defined in B.1.2.
When processing 严格模式代码, the extensions defined in B.3.2, B.3.3, B.3.4, and B.3.6 must not be supported.
When parsing for the Module 目标符, the 词法 extensions defined in B.1.3 must not be supported.

17ES 标准内置对象

每当一个 ES 脚本或模块开始执行时，总会有一些内置对象是可以使用的。一是作为执行程序词法环境的全局对象；其他的则是一些可以被访问的全局对象的初始化属性或是直接作为可访问的内置对象的属性。

除非另有规定，一个内置对象（可以被作为一个函数调用）是一个内置函数对象（携带一些规格参数，见 9.3）。除非另有规定，内置对象的内部属性 [[Extensible]] 有一个初始值 true。每一个内置函数对象都有一个 [[Realm]] 内部属性，其值是对象被初始化创建时的 realm 的 Realm Record。

许多内置对象是函数：它们可以通过参数调用。其中有些还可以作为构造器：这些函数可被 new 运算符调用。对于每个内置函数，本规范描述了这些函数的必须参数和函数对象的属性。对于每个内置构造器，本规范还描述了这些构造器的 prototype 对象的属性，还描述了用 new 表达式调用这个构造器后返回的具体实例对象的属性。

除非对某一特定函数的描述另有规定，如果一个内置函数或构造器在被调用时传入的参数少于必须的参数个数，那么这个函数或构造器将表现为仿佛传入了足够的参数，而那些缺少的参数会设定为 undefined 值。这些遗失的参数会被认为是“不存在的” and may be identified in that manner by specification 算法. In the description of a particular function, the terms “this value” and “NewTarget” have the meanings given in 9.3.

除非另外指明了某一特定函数的描述，如果在调用一个内置函数或构造器时传入了比函数指定允许的更多的参数时，额外的参数会被函数忽略。然而，一个实现可以为这样的参数列表定义依赖于实现的特别行为，只要这种行为在单纯添加额外参数时不抛出 TypeError 异常。

Note 1

实现为了给内置函数集合增添一些额外功能而添加新函数是被鼓励去做的，而不是为现有函数增加新的参数。

除非另有规定，每个内置函数和每个内置构造器都有 Function 原型对象（其是 Function.prototype (19.2.3) 表达式的初始值），作为其内部属性 [[Prototype]] 的值。

除非另有规定，每一个内置原型对象都有一个对象原型对象（其是表达式 Object.prototype (19.1.3) 的初始值），作为它的内部属性 [[Prototype]] 的值，除了对象原型对象自身。

除非另外指明了一个特定函数的描述，否则没有被确定为构造器的内置函数对象中没有实现内部方法 [[Construct]]。

每一个定义在本规范中的内置函数都可以通过调用抽象操作 CreateBuiltinFunction 来创建(9.3.3)。

每个内置函数对象，包括构造器，都有一个值为整数的 length 属性。除非另有规定，此值等于显示在函数描述的子章节标题的命名参数的最大个数。可选参数（使用形如 «...name»）不被记入默认参数的数量。

Note 2

例如, the 函数对象 that is the 初始值 of the map property of the Array 原型对象 is described under the subclause heading «Array.prototype.map (callbackFn [ , thisArg])» which shows the two named arguments callbackFn and thisArg, the latter being optional; therefore the value of the length property of that 函数对象 is 1.

除非另有规定，内置函数对象的 length 属性拥有如下特性：{ [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

每个不被确定为匿名函数的内置函数对象，包括构造器，都有一个值为字符串的 name 属性。除非另有规定，本规范中，这个 name 的值由函数给出。对于被指定为对象属性的函数，这个 name 的值就是用来访问该函数的属性名字符串。Functions that are specified as get or set accessor functions of 内置 properties have "get " or "set " prepended to the 属性名 string. 对于属性值是符号值的每个内置函数，属性 name 的值被显示地指定。

Unless otherwise specified, the name property of a 内置函数对象, if it exists, has the 特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

Every other 数据属性 described in clauses 18 through 26 and in Annex B.2 has the 特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true } unless otherwise specified.

Every 访问器属性 described in clauses 18 through 26 and in Annex B.2 has the 特性 { [[Enumerable]]: false, [[Configurable]]: true } unless otherwise specified. If only a get 访问器函数 is described, the set 访问器函数 is the 默认值, undefined. If only a set accessor is described the get accessor is the 默认值, undefined.

18全局对象

在控制进入任何执行上下文后，这个唯一的全局对象会被创建。

全局对象没有 [[Construct]] 内部属性 ; 全局对象不可能当做构造器用 new 运算符调用。

全局对象没有 [[Call]] 内部属性，全局对象不可能当做函数来调用。

全局对象的 [[Prototype]] 内部属性值是依赖于实现的。

除了本规范定义的属性之外，全局对象还可以拥有额外的宿主定义的属性。全局对象可包含一个值是全局对象自身的属性；例如，在 HTML 文档对象模型中全局对象的 window 属性是全局对象自身。

18.1全局对象的值属性

18.1.1Infinity

Infinity 的值是 +∞ (见 6.1.6)。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

18.1.2NaN

NaN 的值是 NaN（见 6.1.6）。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

18.1.3undefined

undefined 的值是 undefined（见 6.1.1）。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

18.2全局对象的函数属性

18.2.1eval ( `x` )

eval 函数是 %eval% 内部对象。当 eval 函数用一个参数 x 调用时，会采取以下步骤：

Assert: The 执行上下文堆栈 has at least two elements.
Let callerContext be the second to top element of the 执行上下文堆栈.
Let callerRealm be callerContext's Realm.
Let calleeRealm be the current Realm Record.
Perform ? HostEnsureCanCompileStrings(callerRealm, calleeRealm).
Return ? PerformEval(x, calleeRealm, false, false).

18.2.1.1运行时语义: PerformEval ( `x`, `evalRealm`, `strictCaller`, `direct` )

The 抽象操作 PerformEval with arguments x, evalRealm, strictCaller, and direct 执行如下:

Assert: If direct is false, then strictCaller is also false.
If Type(x) is not String, return x.
Let thisEnvRec be ! GetThisEnvironment().
If thisEnvRec is a 函数环境记录, then
1. Let F be thisEnvRec.[[FunctionObject]].
2. Let inFunction be true.
3. Let inMethod be thisEnvRec.HasSuperBinding().
4. If F.[[ConstructorKind]] is "derived", let inDerivedConstructor be true; otherwise, let inDerivedConstructor be false.
Else,
1. Let inFunction be false.
2. Let inMethod be false.
3. Let inDerivedConstructor be false.
Let script be the ES 代码 that is the result of parsing x, interpreted as UTF-16 encoded Unicode text as described in 6.1.4, for the 目标符 Script. If inFunction is false, additional 早期错误 rules from 18.2.1.1.1 are applied. If inMethod is false, additional 早期错误 rules from 18.2.1.1.2 are applied. If inDerivedConstructor is false, additional 早期错误 rules from 18.2.1.1.3 are applied. If the parse fails, 抛出一个 SyntaxError 异常. If any 早期错误 are detected, 抛出一个 SyntaxError or a ReferenceError 异常, depending on the type of the error (but see also clause 16). Parsing and 早期错误 detection may be interweaved in an 实现-dependent manner.
If script Contains ScriptBody is false, return undefined.
Let body be the ScriptBody of script.
If strictCaller is true, let strictEval be true.
Else, let strictEval be IsStrict of script.
Let ctx be the 运行时执行上下文.
NOTE: If direct is true, ctx will be the 执行上下文 that performed the direct eval. If direct is false, ctx will be the 执行上下文 for the invocation of the eval function.
If direct is true, then
1. Let lexEnv be NewDeclarativeEnvironment(ctx's LexicalEnvironment).
2. Let varEnv be ctx's VariableEnvironment.
Else,
1. Let lexEnv be NewDeclarativeEnvironment(evalRealm.[[GlobalEnv]]).
2. Let varEnv be evalRealm.[[GlobalEnv]].
If strictEval is true, set varEnv to lexEnv.
If ctx is not already suspended, suspend ctx.
Let evalCxt be a new ES 代码执行上下文.
Set the evalCxt's Function to null.
Set the evalCxt's Realm to evalRealm.
Set the evalCxt's ScriptOrModule to ctx's ScriptOrModule.
Set the evalCxt's VariableEnvironment to varEnv.
Set the evalCxt's LexicalEnvironment to lexEnv.
Push evalCxt on to the 执行上下文堆栈; evalCxt is now the 运行时执行上下文.
Let result be EvalDeclarationInstantiation(body, varEnv, lexEnv, strictEval).
If result.[[Type]] is normal, then
1. Set result to the result of evaluating body.
If result.[[Type]] is normal and result.[[Value]] is empty, then
1. Set result to NormalCompletion(undefined).
Suspend evalCxt and remove it from the 执行上下文堆栈.
Resume the context that is now on the top of the 执行上下文堆栈 as the 运行时执行上下文.
Return Completion(result).

Note

The eval code cannot instantiate variable or function bindings in the variable environment of the calling context that invoked the eval if the calling context is evaluating formal parameter 初始化器 or if either the code of the calling context or the eval code is 严格模式代码. Instead such bindings are instantiated in a new VariableEnvironment that is only accessible to the eval code. Bindings introduced by let, const, or class declarations are always instantiated in a new LexicalEnvironment.

18.2.1.1.1Additional 早期错误 Rules for Eval Outside Functions

These 静态语义 are applied by PerformEval when a direct eval call occurs outside of any function.

这是一个句法错误如果 StatementList Contains NewTarget.

18.2.1.1.2Additional 早期错误 Rules for Eval Outside Methods

These 静态语义 are applied by PerformEval when a direct eval call occurs outside of a MethodDefinition.

这是一个句法错误如果 StatementList Contains SuperProperty.

18.2.1.1.3Additional 早期错误 Rules for Eval Outside 构造器 Methods

These 静态语义 are applied by PerformEval when a direct eval call occurs outside of the 构造器 method of a ClassDeclaration or ClassExpression.

这是一个句法错误如果 StatementList Contains SuperCall.

18.2.1.2HostEnsureCanCompileStrings( `callerRealm`, `calleeRealm` )

HostEnsureCanCompileStrings is an 实现-defined 抽象操作 that allows 宿主环境 to block certain ES functions which allow developers to compile strings into ES 代码.

An 实现 of HostEnsureCanCompileStrings may complete normally or abruptly. Any abrupt completions will be propagated to its callers. The default 实现 of HostEnsureCanCompileStrings is to unconditionally return an empty normal completion.

18.2.1.3运行时语义: EvalDeclarationInstantiation( `body`, `varEnv`, `lexEnv`, `strict` )

When the 抽象操作 EvalDeclarationInstantiation is called with arguments body, varEnv, lexEnv, and strict, 执行如下:

Let varNames be the VarDeclaredNames of body.
Let varDeclarations be the VarScopedDeclarations of body.
Let lexEnvRec be lexEnv's EnvironmentRecord.
Let varEnvRec be varEnv's EnvironmentRecord.
If strict is false, then
1. If varEnvRec is a global 环境记录, then
  1. For each name in varNames, do
    1. If varEnvRec.HasLexicalDeclaration(name) is true, 抛出一个 SyntaxError 异常.
    2. NOTE: eval will not create a global var declaration that would be shadowed by a global lexical declaration.
2. Let thisLex be lexEnv.
3. Assert: The following loop will terminate.
4. Repeat, while thisLex is not the same as varEnv,
  1. Let thisEnvRec be thisLex's EnvironmentRecord.
  2. If thisEnvRec is not an object 环境记录, then
    1. NOTE: The environment of with statements cannot contain any lexical declaration so it doesn't need to be checked for var/let hoisting conflicts.
    2. For each name in varNames, do
      1. If thisEnvRec.HasBinding(name) is true, then
        抛出一个 SyntaxError 异常.
        NOTE: Annex B.3.5 defines alternate 语义 for the above step.
      2. NOTE: A direct eval will not hoist var declaration over a like-named lexical declaration.
  3. Set thisLex to thisLex's outer environment reference.
Let functionsToInitialize be a new empty List.
Let declaredFunctionNames be a new empty List.
For each d in varDeclarations, in reverse list order, do
1. If d is neither a VariableDeclaration nor a ForBinding nor a BindingIdentifier, then
  1. Assert: d is either a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration.
  2. NOTE: If there are multiple 函数声明 for the same name, the last declaration is used.
  3. Let fn be the sole element of the 绑定名 of d.
  4. If fn is not an element of declaredFunctionNames, then
    1. If varEnvRec is a global 环境记录, then
      1. Let fnDefinable be ? varEnvRec.CanDeclareGlobalFunction(fn).
      2. If fnDefinable is false, 抛出一个 TypeError 异常.
    2. Append fn to declaredFunctionNames.
    3. Insert d as the first element of functionsToInitialize.
NOTE: Annex B.3.3.3 adds additional steps at this point.
Let declaredVarNames be a new empty List.
For each d in varDeclarations, do
1. If d is a VariableDeclaration, a ForBinding, or a BindingIdentifier, then
  1. For each String vn in the 绑定名 of d, do
    1. If vn is not an element of declaredFunctionNames, then
      1. If varEnvRec is a global 环境记录, then
        Let vnDefinable be ? varEnvRec.CanDeclareGlobalVar(vn).
        If vnDefinable is false, 抛出一个 TypeError 异常.
      2. If vn is not an element of declaredVarNames, then
        Append vn to declaredVarNames.
NOTE: No abnormal terminations occur after this 算法步骤 unless varEnvRec is a global 环境记录 and the 全局对象 is a Proxy 外来对象.
Let lexDeclarations be the LexicallyScopedDeclarations of body.
For each element d in lexDeclarations, do
1. NOTE: Lexically declared names are only instantiated here but not initialized.
2. For each element dn of the 绑定名 of d, do
  1. If IsConstantDeclaration of d is true, then
    1. Perform ? lexEnvRec.CreateImmutableBinding(dn, true).
  2. Else,
    1. Perform ? lexEnvRec.CreateMutableBinding(dn, false).
For each 解析节点 f in functionsToInitialize, do
1. Let fn be the sole element of the 绑定名 of f.
2. Let fo be the result of performing InstantiateFunctionObject for f with argument lexEnv.
3. If varEnvRec is a global 环境记录, then
  1. Perform ? varEnvRec.CreateGlobalFunctionBinding(fn, fo, true).
4. Else,
  1. Let bindingExists be varEnvRec.HasBinding(fn).
  2. If bindingExists is false, then
    1. Let status be ! varEnvRec.CreateMutableBinding(fn, true).
    2. Assert: status is not an abrupt completion because of validation preceding step 12.
    3. Perform ! varEnvRec.InitializeBinding(fn, fo).
  3. Else,
    1. Perform ! varEnvRec.SetMutableBinding(fn, fo, false).
For each String vn in declaredVarNames, in list order, do
1. If varEnvRec is a global 环境记录, then
  1. Perform ? varEnvRec.CreateGlobalVarBinding(vn, true).
2. Else,
  1. Let bindingExists be varEnvRec.HasBinding(vn).
  2. If bindingExists is false, then
    1. Let status be ! varEnvRec.CreateMutableBinding(vn, true).
    2. Assert: status is not an abrupt completion because of validation preceding step 12.
    3. Perform ! varEnvRec.InitializeBinding(vn, undefined).
Return NormalCompletion(empty).

Note

An alternative version of this 算法 is described in B.3.5.

18.2.2isFinite ( `number` )

The isFinite function is the %isFinite% 内部对象. When the isFinite function is called with one argument number, 执行如下:

Let num be ? ToNumber(number).
If num is NaN, +∞, or -∞, return false.
Otherwise, return true.

18.2.3isNaN ( `number` )

The isNaN function is the %isNaN% 内部对象. When the isNaN function is called with one argument number, 执行如下:

Let num be ? ToNumber(number).
If num is NaN, return true.
Otherwise, return false.

Note

A reliable way for ES 代码 to test if a value X is a NaN is an expression of the form X !== X. The result will be true if and only if X is a NaN.

18.2.4parseFloat ( `string` )

The parseFloat function produces a Number 值 dictated by interpretation of the contents of the string argument as a decimal literal.

The parseFloat function is the %parseFloat% 内部对象. When the parseFloat function is called with one argument string, 执行如下:

Let inputString be ? ToString(string).
Let trimmedString be a substring of inputString consisting of the leftmost 代码单元 that is not a StrWhiteSpaceChar and all 代码单元 to the right of that 代码单元. (In other words, remove leading 空白.) If inputString does not contain any such 代码单元, let trimmedString be the empty string.
If neither trimmedString nor any prefix of trimmedString satisfies the syntax of a StrDecimalLiteral (see 7.1.3.1), return NaN.
Let numberString be the longest prefix of trimmedString, which might be trimmedString itself, that satisfies the syntax of a StrDecimalLiteral.
Let mathFloat be MV of numberString.
If mathFloat=0, then
1. If the first 代码单元 of trimmedString is the 代码单元 0x002D (HYPHEN-MINUS), return -0.
2. Return +0.
Return the Number 值 for mathFloat.

Note

parseFloat may interpret only a leading portion of string as a Number 值; it ignores any 代码单元 that cannot be interpreted as part of the notation of a decimal literal, and no indication is given that any such 代码单元 were ignored.

18.2.5parseInt ( `string`, `radix` )

The parseInt function produces an integer value dictated by interpretation of the contents of the string argument according to the specified radix. Leading 空白 in string is ignored. If radix is undefined or 0, it is assumed to be 10 except when the number begins with the 代码单元 pairs 0x or 0X, in which case a radix of 16 is assumed. If radix is 16, the number may also optionally begin with the 代码单元 pairs 0x or 0X.

The parseInt function is the %parseInt% 内部对象. When the parseInt function is called, 执行如下:

Let inputString be ? ToString(string).
Let S be a newly created substring of inputString consisting of the first 代码单元 that is not a StrWhiteSpaceChar and all 代码单元 following that 代码单元. (In other words, remove leading 空白.) If inputString does not contain any such 代码单元, let S be the empty string.
Let sign be 1.
If S is not empty and the first 代码单元 of S is the 代码单元 0x002D (HYPHEN-MINUS), let sign be -1.
If S is not empty and the first 代码单元 of S is the 代码单元 0x002B (PLUS SIGN) or the 代码单元 0x002D (HYPHEN-MINUS), remove the first 代码单元 from S.
Let R be ? ToInt32(radix).
Let stripPrefix be true.
If R ≠ 0, then
1. If R < 2 or R > 36, return NaN.
2. If R ≠ 16, let stripPrefix be false.
Else R = 0,
1. Let R be 10.
If stripPrefix is true, then
1. If the length of S is at least 2 and the first two 代码单元 of S are either "0x" or "0X", remove the first two 代码单元 from S and let R be 16.
If S contains a 代码单元 that is not a radix-R digit, let Z be the substring of S consisting of all 代码单元 before the first such 代码单元; otherwise, let Z be S.
If Z is empty, return NaN.
Let mathInt be the mathematical integer value that is represented by Z in radix-R notation, using the letters A-Z and a-z for digits with values 10 through 35. (However, if R is 10 and Z contains more than 20 significant digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the 实现; and if R is not 2, 4, 8, 10, 16, or 32, then mathInt may be an 实现-dependent approximation to the mathematical integer value that is represented by Z in radix-R notation.)
If mathInt = 0, then
1. If sign = -1, return -0.
2. Return +0.
Let number be the Number 值 for mathInt.
Return sign × number.

Note

parseInt may interpret only a leading portion of string as an integer value; it ignores any 代码单元 that cannot be interpreted as part of the notation of an integer, and no indication is given that any such 代码单元 were ignored.

18.2.6URI 处理函数

Uniform Resource 标识符, or URIs, are Strings that identify resources (e.g. web pages or files) and transport protocols by which to access them (e.g. HTTP or FTP) on the Internet. The ES language itself does not provide any support for using URIs except for functions that encode and decode URIs as described in 18.2.6.2, 18.2.6.3, 18.2.6.4 and 18.2.6.5

Note

Many implementations of ES provide additional functions and methods that manipulate web pages; these functions are beyond the scope of this standard.

18.2.6.1URI 句法和语义

A URI is composed of a sequence of components separated by component separators. The general form is:

Scheme

:

First

/

Second

;

Third

?

Fourth

where the italicized names represent components and “:”, “/”, “;” and “?” are reserved for use as separators. The encodeURI and decodeURI functions are intended to work with complete URIs; they assume that any reserved 代码单元 in the URI are intended to have special meaning and so are not encoded. The encodeURIComponent and decodeURIComponent functions are intended to work with the individual component parts of a URI; they assume that any reserved 代码单元 represent text and so must be encoded so that they are not interpreted as reserved 代码单元 when the component is part of a complete URI.

The following 词法 specifies the form of encoded URIs.

Syntax

:::

opt

:::

opt

:::

:::

one of

;

:::

:::

:::

one of

uriMark

:::

one of

(

)

Note

The above syntax is based upon RFC 2396 and does not reflect changes introduced by the more recent RFC 3986.

运行时语义

When a 代码单元 to be included in a URI is not listed above or is not intended to have the special meaning sometimes given to the reserved 代码单元, that 代码单元 must be encoded. The 代码单元 is transformed into its UTF-8 encoding, with surrogate pairs first converted from UTF-16 to the corresponding 码点 value. (Note that for 代码单元 in the range [0,127] this results in a single octet with the same value.) The resulting sequence of octets is then transformed into a String with each octet represented by an escape sequence of the form "%xx".

18.2.6.1.1运行时语义: Encode ( `string`, `unescapedSet` )

The encoding and escaping process is described by the 抽象操作 Encode taking two String arguments string and unescapedSet.

Let strLen be the number of 代码单元 in string.
Let R be the empty String.
Let k be 0.
Repeat,
1. If k equals strLen, return R.
2. Let C be the 代码单元 at index k within string.
3. If C is in unescapedSet, then
  1. Let S be the String 值 containing only the 代码单元 C.
  2. Set R to the string-concatenation of the previous value of R and S.
4. Else C is not in unescapedSet,
  1. If the 数字值 of C is not less than 0xDC00 and not greater than 0xDFFF, 抛出一个 URIError 异常.
  2. If the 数字值 of C is less than 0xD800 or greater than 0xDBFF, then
    1. Let V be the 码点 with the same 数字值 as 代码单元 C.
  3. Else,
    1. Increase k by 1.
    2. If k equals strLen, 抛出一个 URIError 异常.
    3. Let kChar be the 数字值 of the 代码单元 at index k within string.
    4. If kChar is less than 0xDC00 or greater than 0xDFFF, 抛出一个 URIError 异常.
    5. Let V be UTF16Decode(C, kChar).
  4. Let Octets be the List of octets resulting by applying the UTF-8 transformation to V.
  5. For each element octet of Octets in List order, do
    1. Let S be the string-concatenation of "%" and the two uppercase hexadecimal digits encoding octet.
    2. Set R to the string-concatenation of the previous value of R and S.
5. Increase k by 1.

18.2.6.1.2运行时语义: Decode ( `string`, `reservedSet` )

The unescaping and decoding process is described by the 抽象操作 Decode taking two String arguments string and reservedSet.

Let strLen be the number of 代码单元 in string.
Let R be the empty String.
Let k be 0.
Repeat,
1. If k equals strLen, return R.
2. Let C be the 代码单元 at index k within string.
3. If C is not the 代码单元 0x0025 (PERCENT SIGN), then
  1. Let S be the String 值 containing only the 代码单元 C.
4. Else C is the 代码单元 0x0025 (PERCENT SIGN),
  1. Let start be k.
  2. If k + 2 is greater than or equal to strLen, 抛出一个 URIError 异常.
  3. If the 代码单元 at index (k + 1) and (k + 2) within string do not represent hexadecimal digits, 抛出一个 URIError 异常.
  4. Let B be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
  5. Increment k by 2.
  6. If the most significant bit in B is 0, then
    1. Let C be the 代码单元 whose value is B.
    2. If C is not in reservedSet, then
      1. Let S be the String 值 containing only the 代码单元 C.
    3. Else C is in reservedSet,
      1. Let S be the substring of string from index start to index k inclusive.
  7. Else the most significant bit in B is 1,
    1. Let n be the smallest nonnegative integer such that (B << n) & 0x80 is equal to 0.
    2. If n equals 1 or n is greater than 4, 抛出一个 URIError 异常.
    3. Let Octets be a List of 8-bit integers of size n.
    4. Set Octets[0] to B.
    5. If k + (3 × (n - 1)) is greater than or equal to strLen, 抛出一个 URIError 异常.
    6. Let j be 1.
    7. Repeat, while j < n
      1. Increment k by 1.
      2. If the 代码单元 at index k within string is not the 代码单元 0x0025 (PERCENT SIGN), 抛出一个 URIError 异常.
      3. If the 代码单元 at index (k + 1) and (k + 2) within string do not represent hexadecimal digits, 抛出一个 URIError 异常.
      4. Let B be the 8-bit value represented by the two hexadecimal digits at index (k + 1) and (k + 2).
      5. If the two most significant bits in B are not 10, 抛出一个 URIError 异常.
      6. Increment k by 2.
      7. Set Octets[j] to B.
      8. Increment j by 1.
    8. If Octets does not contain a valid UTF-8 encoding of a Unicode 码点, 抛出一个 URIError 异常.
    9. Let V be the value obtained by applying the UTF-8 transformation to Octets, that is, from a List of octets into a 21-bit value.
    10. Let S be the String 值 whose elements are, in order, the elements in UTF16Encoding(V).
5. Set R to the string-concatenation of the previous value of R and S.
6. Increase k by 1.

Note

This syntax of Uniform Resource 标识符 is based upon RFC 2396 and does not reflect the more recent RFC 3986 which replaces RFC 2396. A formal description and 实现 of UTF-8 is given in RFC 3629.

In UTF-8, characters are encoded using sequences of 1 to 6 octets. The only octet of a sequence of one has the higher-order bit set to 0, the remaining 7 bits being used to encode the character value. In a sequence of n octets, n>1, the initial octet has the n higher-order bits set to 1, followed by a bit set to 0. The remaining bits of that octet contain bits from the value of the character to be encoded. The following octets all have the higher-order bit set to 1 and the following bit set to 0, leaving 6 bits in each to contain bits from the character to be encoded. The possible UTF-8 encodings of ES characters are specified in Table 44.

Table 44 (Informative): UTF-8 Encodings

代码单元 Value	Representation	1^st Octet	2^nd Octet	3^rd Octet	4^th Octet
`0x0000 - 0x007F`	`00000000 0zzzzzzz`	`0zzzzzzz`
`0x0080 - 0x07FF`	`00000yyy yyzzzzzz`	`110yyyyy`	`10zzzzzz`
`0x0800 - 0xD7FF`	`xxxxyyyy yyzzzzzz`	`1110xxxx`	`10yyyyyy`	`10zzzzzz`
`0xD800 - 0xDBFF` followed by `0xDC00 - 0xDFFF`	`110110vv vvwwwwxx` followed by `110111yy yyzzzzzz`	`11110uuu`	`10uuwwww`	`10xxyyyy`	`10zzzzzz`
`0xD800 - 0xDBFF` not followed by `0xDC00 - 0xDFFF`	causes `URIError`
`0xDC00 - 0xDFFF`	causes `URIError`
`0xE000 - 0xFFFF`	`xxxxyyyy yyzzzzzz`	`1110xxxx`	`10yyyyyy`	`10zzzzzz`

Where
uuuuu = vvvv + 1
to account for the addition of 0x10000 as in Surrogates, section 3.8, of the Unicode Standard.

The range of 代码单元 values 0xD800-0xDFFF is used to encode surrogate pairs; the above transformation combines a UTF-16 代理对 into a UTF-32 representation and encodes the resulting 21-bit value in UTF-8. Decoding reconstructs the 代理对.

RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. 例如, the invalid sequence C0 80 must not decode into the 代码单元 0x0000. Implementations of the Decode 算法 are required to 抛出一个 URIError when encountering such invalid sequences.

18.2.6.2decodeURI ( `encodedURI` )

The decodeURI function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURI function is replaced with the UTF-16 encoding of the code points that it represents. Escape sequences that could not have been introduced by encodeURI are not replaced.

The decodeURI function is the %decodeURI% 内部对象. When the decodeURI function is called with one argument encodedURI, 执行如下:

Let uriString be ? ToString(encodedURI).
Let reservedURISet be a String containing one instance of each 代码单元 valid in uriReserved plus "#".
Return ? Decode(uriString, reservedURISet).

Note

The 码点 "#" is not decoded from escape sequences even though it is not a reserved URI 码点.

18.2.6.3decodeURIComponent ( `encodedURIComponent` )

The decodeURIComponent function computes a new version of a URI in which each escape sequence and UTF-8 encoding of the sort that might be introduced by the encodeURIComponent function is replaced with the UTF-16 encoding of the code points that it represents.

The decodeURIComponent function is the %decodeURIComponent% 内部对象. When the decodeURIComponent function is called with one argument encodedURIComponent, 执行如下:

Let componentString be ? ToString(encodedURIComponent).
Let reservedURIComponentSet be the empty String.
Return ? Decode(componentString, reservedURIComponentSet).

18.2.6.4encodeURI ( `uri` )

The encodeURI function computes a new version of a UTF-16 encoded (6.1.4) URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the code points.

The encodeURI function is the %encodeURI% 内部对象. When the encodeURI function is called with one argument uri, 执行如下:

Let uriString be ? ToString(uri).
Let unescapedURISet be a String containing one instance of each 代码单元 valid in uriReserved and uriUnescaped plus "#".
Return ? Encode(uriString, unescapedURISet).

Note

The 代码单元 "#" is not encoded to an escape sequence even though it is not a reserved or unescaped URI 码点.

18.2.6.5encodeURIComponent ( `uriComponent` )

The encodeURIComponent function computes a new version of a UTF-16 encoded (6.1.4) URI in which each instance of certain code points is replaced by one, two, three, or four escape sequences representing the UTF-8 encoding of the 码点.

The encodeURIComponent function is the %encodeURIComponent% 内部对象. When the encodeURIComponent function is called with one argument uriComponent, 执行如下:

Let componentString be ? ToString(uriComponent).
Let unescapedURIComponentSet be a String containing one instance of each 代码单元 valid in uriUnescaped.
Return ? Encode(componentString, unescapedURIComponentSet).

18.3全局对象的构造器属性

18.3.1Array ( . . . )

See 22.1.1.

18.3.2ArrayBuffer ( . . . )

See 24.1.2.

18.3.3Boolean ( . . . )

See 19.3.1.

18.3.4DataView ( . . . )

See 24.3.2.

18.3.5Date ( . . . )

See 20.3.2.

18.3.6Error ( . . . )

See 19.5.1.

18.3.7EvalError ( . . . )

See 19.5.5.1.

18.3.8Float32Array ( . . . )

See 22.2.4.

18.3.9Float64Array ( . . . )

See 22.2.4.

18.3.10Function ( . . . )

See 19.2.1.

18.3.11Int8Array ( . . . )

See 22.2.4.

18.3.12Int16Array ( . . . )

See 22.2.4.

18.3.13Int32Array ( . . . )

See 22.2.4.

18.3.14Map ( . . . )

See 23.1.1.

18.3.15Number ( . . . )

See 20.1.1.

18.3.16Object ( . . . )

See 19.1.1.

18.3.17Proxy ( . . . )

See 26.2.1.

18.3.18Promise ( . . . )

See 25.6.3.

18.3.19RangeError ( . . . )

See 19.5.5.2.

18.3.20ReferenceError ( . . . )

See 19.5.5.3.

18.3.21RegExp ( . . . )

See 21.2.3.

18.3.22Set ( . . . )

See 23.2.1.

18.3.23SharedArrayBuffer ( . . . )

See 24.2.2.

18.3.24String ( . . . )

See 21.1.1.

18.3.25Symbol ( . . . )

See 19.4.1.

18.3.26SyntaxError ( . . . )

See 19.5.5.4.

18.3.27TypeError ( . . . )

See 19.5.5.5.

18.3.28Uint8Array ( . . . )

See 22.2.4.

18.3.29Uint8ClampedArray ( . . . )

See 22.2.4.

18.3.30Uint16Array ( . . . )

See 22.2.4.

18.3.31Uint32Array ( . . . )

See 22.2.4.

18.3.32URIError ( . . . )

See 19.5.5.6.

18.3.33WeakMap ( . . . )

See 23.3.1.

18.3.34WeakSet ( . . . )

See 23.4.

18.4全局对象的其它属性

18.4.1Atomics

See 24.4.

18.4.2JSON

See 24.5.

18.4.3Math

See 20.2.

18.4.4Reflect

See 26.1.

19基础对象

19.1Object 对象

19.1.1对象构造器

对象构造器是 %Object% 内部对象和全局对象的 Object 属性的初始值。当作为一个构造器被调用时，它会创建一个新的普通对象。当把 Object 作为函数而不是构造器被调用时，它会执行一个类型转换。

Object 构造器被设计成可被再细分的，它可能会被用来作为一个类定义的 extends 语句的值。

19.1.1.1Object ( [ `value` ] )

当一一个可选的参数 value 调用 Object 函数时，会采用以下步骤：

If NewTarget is neither undefined nor the active function, then
1. Return ? OrdinaryCreateFromConstructor(NewTarget, "%ObjectPrototype%").
If value is null, undefined or not supplied, return ObjectCreate(%ObjectPrototype%).
Return ! ToObject(value).

The length property of the Object 构造器 function is 1.

19.1.2Object 构造器的属性

对象构造器的内部属性 [[Prototype]] 的值是内部对象 %FunctionPrototype%。

除了 length 属性，对象构造器还有以下属性：

19.1.2.1Object.assign ( `target`, ...`sources` )

assign 函数用来复制一个或多个源对象中所有可枚举的自身属性的值给目标对象。当 assign 函数被调用时，会采取以下步骤：

Let to be ? ToObject(target).
If only one argument was passed, return to.
Let sources be the List of argument values starting with the second argument.
For each element nextSource of sources, in ascending index order, do
1. If nextSource is undefined or null, let keys be a new empty List.
2. Else,
  1. Let from be ! ToObject(nextSource).
  2. Let keys be ? from.[[OwnPropertyKeys]]().
3. For each element nextKey of keys in List order, do
  1. Let desc be ? from.[[GetOwnProperty]](nextKey).
  2. If desc is not undefined and desc.[[Enumerable]] is true, then
    1. Let propValue be ? Get(from, nextKey).
    2. Perform ? Set(to, nextKey, propValue, true).
Return to.

The length property of the assign function is 2.

19.1.2.2Object.create ( `O`, `Properties` )

create 函数用一个指定的原型对象来创建一个新的对象。当 create 函数被调用时，会采用以下步骤：

If Type(O) is neither Object nor Null, 抛出一个 TypeError 异常.
Let obj be ObjectCreate(O).
If Properties is not undefined, then
1. Return ? ObjectDefineProperties(obj, Properties).
Return obj.

19.1.2.3Object.defineProperties ( `O`, `Properties` )

defineProperties 函数用来给一个对象添加自身属性和/或更新现有的自身属性的特性。当 defineProperties 函数被调用时，会采用以下步骤：

Return ? ObjectDefineProperties(O, Properties).

19.1.2.3.1运行时语义: ObjectDefineProperties ( `O`, `Properties` )

The 抽象操作 ObjectDefineProperties with arguments O and Properties 执行如下:

If Type(O) is not Object, 抛出一个 TypeError 异常.
Let props be ? ToObject(Properties).
Let keys be ? props.[[OwnPropertyKeys]]().
Let descriptors be a new empty List.
For each element nextKey of keys in List order, do
1. Let propDesc be ? props.[[GetOwnProperty]](nextKey).
2. If propDesc is not undefined and propDesc.[[Enumerable]] is true, then
  1. Let descObj be ? Get(props, nextKey).
  2. Let desc be ? ToPropertyDescriptor(descObj).
  3. Append the pair (a two element List) consisting of nextKey and desc to the end of descriptors.
For each pair from descriptors in list order, do
1. Let P be the first element of pair.
2. Let desc be the second element of pair.
3. Perform ? DefinePropertyOrThrow(O, P, desc).
Return O.

19.1.2.4Object.defineProperty ( `O`, `P`, `特性` )

defineProperty 函数用来给对象添加一个自身属性和/或更新现有的自身属性的特性。当 defineProperty 函数被调用时，会采用以下步骤：

If Type(O) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(P).
Let desc be ? ToPropertyDescriptor(特性).
Perform ? DefinePropertyOrThrow(O, key, desc).
Return O.

19.1.2.5Object.entries ( `O` )

When the entries function is called with argument O, 执行如下:

Let obj be ? ToObject(O).
Let nameList be ? EnumerableOwnPropertyNames(obj, "key+value").
Return CreateArrayFromList(nameList).

19.1.2.6Object.freeze ( `O` )

When the freeze function is called, 执行如下:

If Type(O) is not Object, return O.
Let status be ? SetIntegrityLevel(O, "frozen").
If status is false, 抛出一个 TypeError 异常.
Return O.

19.1.2.7Object.getOwnPropertyDescriptor ( `O`, `P` )

When the getOwnPropertyDescriptor function is called, 执行如下:

Let obj be ? ToObject(O).
Let key be ? ToPropertyKey(P).
Let desc be ? obj.[[GetOwnProperty]](key).
Return FromPropertyDescriptor(desc).

19.1.2.8Object.getOwnPropertyDescriptors ( `O` )

When the getOwnPropertyDescriptors function is called, 执行如下:

Let obj be ? ToObject(O).
Let ownKeys be ? obj.[[OwnPropertyKeys]]().
Let descriptors be ! ObjectCreate(%ObjectPrototype%).
For each element key of ownKeys in List order, do
1. Let desc be ? obj.[[GetOwnProperty]](key).
2. Let descriptor be ! FromPropertyDescriptor(desc).
3. If descriptor is not undefined, perform ! CreateDataProperty(descriptors, key, descriptor).
Return descriptors.

19.1.2.9Object.getOwnPropertyNames ( `O` )

When the getOwnPropertyNames function is called, 执行如下:

Return ? GetOwnPropertyKeys(O, String).

19.1.2.10Object.getOwnPropertySymbols ( `O` )

When the getOwnPropertySymbols function is called with argument O, 执行如下:

Return ? GetOwnPropertyKeys(O, Symbol).

19.1.2.10.1运行时语义: GetOwnPropertyKeys ( `O`, `Type` )

The 抽象操作 GetOwnPropertyKeys is called with arguments O and Type where O is an Object and Type is one of the ES 规范类型 String or Symbol. 执行如下:

Let obj be ? ToObject(O).
Let keys be ? obj.[[OwnPropertyKeys]]().
Let nameList be a new empty List.
For each element nextKey of keys in List order, do
1. If Type(nextKey) is Type, then
  1. Append nextKey as the last element of nameList.
Return CreateArrayFromList(nameList).

19.1.2.11Object.getPrototypeOf ( `O` )

When the getPrototypeOf function is called with argument O, 执行如下:

Let obj be ? ToObject(O).
Return ? obj.[[GetPrototypeOf]]().

19.1.2.12Object.is ( `value1`, `value2` )

When the is function is called with arguments value1 and value2, 执行如下:

Return SameValue(value1, value2).

19.1.2.13Object.isExtensible ( `O` )

When the isExtensible function is called with argument O, 执行如下:

If Type(O) is not Object, return false.
Return ? IsExtensible(O).

19.1.2.14Object.isFrozen ( `O` )

When the isFrozen function is called with argument O, 执行如下:

If Type(O) is not Object, return true.
Return ? TestIntegrityLevel(O, "frozen").

19.1.2.15Object.isSealed ( `O` )

When the isSealed function is called with argument O, 执行如下:

If Type(O) is not Object, return true.
Return ? TestIntegrityLevel(O, "sealed").

19.1.2.16Object.keys ( `O` )

When the keys function is called with argument O, 执行如下:

Let obj be ? ToObject(O).
Let nameList be ? EnumerableOwnPropertyNames(obj, "key").
Return CreateArrayFromList(nameList).

19.1.2.17Object.preventExtensions ( `O` )

When the preventExtensions function is called, 执行如下:

If Type(O) is not Object, return O.
Let status be ? O.[[PreventExtensions]]().
If status is false, 抛出一个 TypeError 异常.
Return O.

19.1.2.18Object.prototype

The 初始值 of Object.prototype is the 内部对象 %ObjectPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.1.2.19Object.seal ( `O` )

When the seal function is called, 执行如下:

If Type(O) is not Object, return O.
Let status be ? SetIntegrityLevel(O, "sealed").
If status is false, 抛出一个 TypeError 异常.
Return O.

19.1.2.20Object.setPrototypeOf ( `O`, `proto` )

When the setPrototypeOf function is called with arguments O and proto, 执行如下:

Let O be ? RequireObjectCoercible(O).
If Type(proto) is neither Object nor Null, 抛出一个 TypeError 异常.
If Type(O) is not Object, return O.
Let status be ? O.[[SetPrototypeOf]](proto).
If status is false, 抛出一个 TypeError 异常.
Return O.

19.1.2.21Object.values ( `O` )

When the values function is called with argument O, 执行如下:

Let obj be ? ToObject(O).
Let nameList be ? EnumerableOwnPropertyNames(obj, "value").
Return CreateArrayFromList(nameList).

19.1.3Object 原型对象属性

Object 原型对象是 %ObjectPrototype% 内部对象。Object 原型对象是一个不可改变的原型外来对象.

Object 原型对象的内部属性 [[Prototype]] 的值是 null，内部属性 [[Extensible]] 的初始值是 true。

19.1.3.1Object.prototype.constructor

Object.prototype.constructor 的初始值是内部对象 %Object%。

19.1.3.2Object.prototype.hasOwnProperty ( `V` )

When the hasOwnProperty method is called with argument V, 执行如下:

Let P be ? ToPropertyKey(V).
Let O be ? ToObject(this value).
Return ? HasOwnProperty(O, P).

Note

The ordering of steps 1 and 2 is chosen to ensure that any 异常 that would have been thrown by step 1 in previous editions of this specification will continue to be thrown even if the this value is undefined or null.

19.1.3.3Object.prototype.isPrototypeOf ( `V` )

When the isPrototypeOf method is called with argument V, 执行如下:

If Type(V) is not Object, return false.
Let O be ? ToObject(this value).
Repeat,
1. Let V be ? V.[[GetPrototypeOf]]().
2. If V is null, return false.
3. If SameValue(O, V) is true, return true.

Note

The ordering of steps 1 and 2 preserves the behaviour specified by previous editions of this specification for the case where V is not an object and the this value is undefined or null.

19.1.3.4Object.prototype.propertyIsEnumerable ( `V` )

When the propertyIsEnumerable method is called with argument V, 执行如下:

Let P be ? ToPropertyKey(V).
Let O be ? ToObject(this value).
Let desc be ? O.[[GetOwnProperty]](P).
If desc is undefined, return false.
Return desc.[[Enumerable]].

Note 1

This method does not consider objects in the prototype chain.

Note 2

19.1.3.5Object.prototype.toLocaleString ( [ `reserved1` [ , `reserved2` ] ] )

When the toLocaleString method is called, 执行如下:

Let O be the this value.
Return ? Invoke(O, "toString").

The optional parameters to this function are not used but are intended to correspond to the parameter pattern used by ECMA-402 toLocaleString functions. Implementations that do not include ECMA-402 support must not use those parameter positions for other purposes.

Note 1

This function provides a generic toLocaleString 实现 for objects that have no locale-specific toString behaviour. Array, Number, Date, and Typed Arrays provide their own locale-sensitive toLocaleString methods.

Note 2

ECMA-402 intentionally does not provide an alternative to this default 实现.

19.1.3.6Object.prototype.toString ( )

When the toString method is called, 执行如下:

If the this value is undefined, return "[object Undefined]".
If the this value is null, return "[object Null]".
Let O be ! ToObject(this value).
Let isArray be ? IsArray(O).
If isArray is true, let builtinTag be "Array".
Else if O is a String 外来对象, let builtinTag be "String".
Else if O has a [[ParameterMap]] 内部属性, let builtinTag be "Arguments".
Else if O has a [[Call]] 内部方法, let builtinTag be "Function".
Else if O has an [[ErrorData]] 内部属性, let builtinTag be "Error".
Else if O has a [[BooleanData]] 内部属性, let builtinTag be "Boolean".
Else if O has a [[NumberData]] 内部属性, let builtinTag be "Number".
Else if O has a [[DateValue]] 内部属性, let builtinTag be "Date".
Else if O has a [[RegExpMatcher]] 内部属性, let builtinTag be "RegExp".
Else, let builtinTag be "Object".
Let tag be ? Get(O, @@toStringTag).
If Type(tag) is not String, let tag be builtinTag.
Return the string-concatenation of "[object ", tag, and "]".

This function is the %ObjProto_toString% 内部对象.

Note

Historically, this function was occasionally used to access the String 值 of the [[Class]] 内部属性 that was used in previous editions of this specification as a nominal type tag for various 内置 objects. The above definition of toString preserves compatibility for legacy code that uses toString as a test for those specific kinds of 内置 objects. It does not provide a reliable type testing mechanism for other kinds of 内置 or program defined objects. In addition, programs can use @@toStringTag in ways that will invalidate the reliability of such legacy type tests.

19.1.3.7Object.prototype.valueOf ( )

When the valueOf method is called, 执行如下:

Return ? ToObject(this value).

This function is the %ObjProto_valueOf% 内部对象.

19.1.4Object 实例的属性

对象实例除了从对象原型对象中继承的属性外，没有特殊属性。

19.2函数对象

19.2.1函数构造器

函数构造器是内部对象 %Function% ，也是全局对象的 Function 属性的初始值。当将 Function 作为函数来调用，而不是构造器时，它会创建并初始化一个新的函数对象。所以函数调用 Function(…) 与用相同参数的对象创建表达式 new Function(…) 的效果相同。

函数构造器被设计为可以再细分的，它可能被用作类定义的 extends 语句的值。子类构造器 that 旨在继承特定的 Function behaviour must include a super call to the Function 构造器 to create and initialize a subclass instance with the 内部属性 necessary for 内置函数 behaviour. All ES syntactic forms for defining 函数对象 create instances of Function. There is no syntactic means to create instances of Function subclasses except for the 内置 GeneratorFunction, AsyncFunction, and AsyncGeneratorFunction subclasses.

19.2.1.1Function ( `p1`, `p2`, … , `pn`, `body` )

最后一个参数指定了一个函数的函数体（可执行的代码）；在最后一个参数之前的任一一个参数指定了一个函数的形式参数。

当以一些参数 p1, p2, … , pn, body 作为参数调用 Function 函数（这里的 n 可以是 0，也就是说可以没有 “p” 参数，这时还可以不提供 body），采用如下步骤：

Let C be the active 函数对象.
Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
Return ? CreateDynamicFunction(C, NewTarget, "normal", args).

Note

It is permissible but not necessary to have one argument for each formal parameter to be specified. 例如, all three of the following expressions produce the same result:

new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")

19.2.1.1.1运行时语义: CreateDynamicFunction( `构造器`, `newTarget`, `kind`, `args` )

The 抽象操作 CreateDynamicFunction is called with arguments 构造器, newTarget, kind, and args. 构造器 is the 构造器 function that is performing this action, newTarget is the 构造器 that new was initially applied to, kind is either "normal", "generator", "async", or "async generator", and args is a List containing the actual argument values that were passed to 构造器. 执行如下:

Assert: The 执行上下文堆栈 has at least two elements.
Let callerContext be the second to top element of the 执行上下文堆栈.
Let callerRealm be callerContext's Realm.
Let calleeRealm be the current Realm Record.
Perform ? HostEnsureCanCompileStrings(callerRealm, calleeRealm).
If newTarget is undefined, set newTarget to 构造器.
If kind is "normal", then
1. Let goal be the grammar symbol FunctionBody[~Yield, ~Await].
2. Let parameterGoal be the grammar symbol FormalParameters[~Yield, ~Await].
3. Let fallbackProto be "%FunctionPrototype%".
Else if kind is "generator", then
1. Let goal be the grammar symbol GeneratorBody.
2. Let parameterGoal be the grammar symbol FormalParameters[+Yield, ~Await].
3. Let fallbackProto be "%Generator%".
Else if kind is "async", then
1. Assert: kind is "async".
2. Let goal be the grammar symbol AsyncFunctionBody.
3. Let parameterGoal be the grammar symbol FormalParameters[~Yield, +Await].
4. Let fallbackProto be "%AsyncFunctionPrototype%".
Else,
1. Assert: kind is "async generator".
2. Let goal be the grammar symbol AsyncGeneratorBody.
3. Let parameterGoal be the grammar symbol FormalParameters[+Yield, +Await].
4. Let fallbackProto be "%AsyncGenerator%".
Let argCount be the number of elements in args.
Let P be the empty String.
If argCount = 0, let bodyText be the empty String.
Else if argCount = 1, let bodyText be args[0].
Else argCount > 1,
1. Let firstArg be args[0].
2. Set P to ? ToString(firstArg).
3. Let k be 1.
4. Repeat, while k < argCount-1
  1. Let nextArg be args[k].
  2. Let nextArgString be ? ToString(nextArg).
  3. Set P to the string-concatenation of the previous value of P, "," (a comma), and nextArgString.
  4. Increase k by 1.
5. Let bodyText be args[k].
Set bodyText to ? ToString(bodyText).
Let parameters be the result of parsing P, interpreted as UTF-16 encoded Unicode text as described in 6.1.4, using parameterGoal as the 目标符. 抛出一个 SyntaxError 异常 if the parse fails.
Let body be the result of parsing bodyText, interpreted as UTF-16 encoded Unicode text as described in 6.1.4, using goal as the 目标符. 抛出一个 SyntaxError 异常 if the parse fails.
Let strict be ContainsUseStrict of body.
If any 静态语义 errors are detected for parameters or body, 抛出一个 SyntaxError or a ReferenceError 异常, depending on the type of the error. If strict is true, the 早期错误 rules for UniqueFormalParameters:FormalParameters are applied. Parsing and 早期错误 detection may be interweaved in an 实现-dependent manner.
If strict is true and IsSimpleParameterList of parameters is false, 抛出一个 SyntaxError 异常.
If any element of the 绑定名 of parameters also occurs in the LexicallyDeclaredNames of body, 抛出一个 SyntaxError 异常.
If body Contains SuperCall is true, 抛出一个 SyntaxError 异常.
If parameters Contains SuperCall is true, 抛出一个 SyntaxError 异常.
If body Contains SuperProperty is true, 抛出一个 SyntaxError 异常.
If parameters Contains SuperProperty is true, 抛出一个 SyntaxError 异常.
If kind is "generator" or "async generator", then
1. If parameters Contains YieldExpression is true, 抛出一个 SyntaxError 异常.
If kind is "async" or "async generator", then
1. If parameters Contains AwaitExpression is true, 抛出一个 SyntaxError 异常.
If strict is true, then
1. If 绑定名 of parameters contains any duplicate elements, 抛出一个 SyntaxError 异常.
Let proto be ? GetPrototypeFromConstructor(newTarget, fallbackProto).
Let F be FunctionAllocate(proto, strict, kind).
Let realmF be F.[[Realm]].
Let scope be realmF.[[GlobalEnv]].
Perform FunctionInitialize(F, Normal, parameters, body, scope).
If kind is "generator", then
1. Let prototype be ObjectCreate(%GeneratorPrototype%).
2. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Else if kind is "async generator", then
1. Let prototype be ObjectCreate(%AsyncGeneratorPrototype%).
2. Perform DefinePropertyOrThrow(F, "prototype", PropertyDescriptor{[[Value]]: prototype, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Else if kind is "normal", perform MakeConstructor(F).
NOTE: Async functions are not constructable and do not have a [[Construct]] 内部方法 or a "prototype" property.
Perform SetFunctionName(F, "anonymous").
Return F.

Note

A prototype property is created for every non-async function created using CreateDynamicFunction to provide for the possibility that the function will be used as a 构造器.

19.2.2Function 构造器属性

Function 构造器本身是一个内置函数对象。Function 构造器的内部属性 [[Prototype]] 的值是内部对象 %FunctionPrototype%。

Function 构造器的内部属性 [[Extensible]] 的值是 true。

Function 构造器有以下属性：

19.2.2.1Function.length

这是一个值为 1 的数据属性。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

19.2.2.2Function.prototype

Function.prototype 的值是内部函数原型对象 %FunctionPrototype%。

这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

19.2.3Function 原型对象的属性

Function 原型对象是内部对象 %FunctionPrototype%。Function 原型对象本身是一个内置函数对象。当被调用时，它可以接收任意个参数和返回 undefined。它没有内部属性 [[Construct]]，所以它不是一个构造器。

Note

Function 原型对象被指定为一个函数对象以确保与ES 2015 规范之前创建的 ES 代码的兼容性。

Function 原型对象的内部属性 [[Prototype]] 的值是内部对象 %ObjectPrototype%。内部属性 [[Extensible]] 的值是 true。

Function 原型对象没有 prototype 属性。

Function 原型对象的 length 属性的值是 0。

Function 原型对象的 name 属性的值是一个空字符串。

19.2.3.1Function.prototype.apply ( `thisArg`, `argArray` )

When the apply method is called on an object func with arguments thisArg and argArray, 执行如下:

If IsCallable(func) is false, 抛出一个 TypeError 异常.
If argArray is undefined or null, then
1. Perform PrepareForTailCall().
2. Return ? Call(func, thisArg).
Let argList be ? CreateListFromArrayLike(argArray).
Perform PrepareForTailCall().
Return ? Call(func, thisArg, argList).

Note 1

The thisArg value is passed without modification as the this value. This is a change from Edition 3, where an undefined or null thisArg is replaced with the 全局对象 and ToObject is applied to all other values and that result is passed as the this value. Even though the thisArg is passed without modification, non-strict functions still perform these transformations upon entry to the function.

Note 2

If func is an arrow function or a bound function then the thisArg will be ignored by the function [[Call]] in step 5.

19.2.3.2Function.prototype.bind ( `thisArg`, ...`args` )

When the bind method is called with argument thisArg and zero or more args, it 执行如下:

Let Target be the this value.
If IsCallable(Target) is false, 抛出一个 TypeError 异常.
Let args be a new (possibly empty) List consisting of all of the argument values provided after thisArg in order.
Let F be ? BoundFunctionCreate(Target, thisArg, args).
Let targetHasLength be ? HasOwnProperty(Target, "length").
If targetHasLength is true, then
1. Let targetLen be ? Get(Target, "length").
2. If Type(targetLen) is not Number, let L be 0.
3. Else,
  1. Let targetLen be ToInteger(targetLen).
  2. Let L be the larger of 0 and the result of targetLen minus the number of elements of args.
Else, let L be 0.
Perform ! DefinePropertyOrThrow(F, "length", PropertyDescriptor {[[Value]]: L, [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true}).
Let targetName be ? Get(Target, "name").
If Type(targetName) is not String, let targetName be the empty string.
Perform SetFunctionName(F, targetName, "bound").
Return F.

Note 1

函数对象 created using Function.prototype.bind are 外来对象. They also do not have a prototype property.

Note 2

If Target is an arrow function or a bound function then the thisArg passed to this method will not be used by subsequent calls to F.

19.2.3.3Function.prototype.call ( `thisArg`, ...`args` )

When the call method is called on an object func with argument, thisArg and zero or more args, 执行如下:

If IsCallable(func) is false, 抛出一个 TypeError 异常.
Let argList be a new empty List.
If this method was called with more than one argument, then in left to right order, starting with the second argument, append each argument as the last element of argList.
Perform PrepareForTailCall().
Return ? Call(func, thisArg, argList).

Note 1

Note 2

If func is an arrow function or a bound function then the thisArg will be ignored by the function [[Call]] in step 5.

19.2.3.4Function.prototype.constructor

The 初始值 of Function.prototype.constructor is the 内部对象 %Function%.

19.2.3.5Function.prototype.toString ( )

When the toString method is called on an object func, 执行如下:

If func is a Bound Function 外来对象, then
1. Return an 实现-dependent String source code representation of func. The representation must conform to the rules below. It is 实现-dependent whether the representation includes bound function information or information about the target function.
If Type(func) is Object and is either a 内置函数对象 or has an [[ECMAScriptCode]] 内部属性, then
1. Return an 实现-dependent String source code representation of func. The representation must conform to the rules below.
抛出一个 TypeError 异常.

toString Representation Requirements:

The string representation must have the syntax of a FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, ArrowFunction, AsyncArrowFunction, or MethodDefinition depending upon the actual characteristics of the object.
The use and placement of 空白, 行终止符, and semicolons within the representation String is 实现-dependent.
If the object was defined using ES 代码 and the returned string representation is not in the form of a MethodDefinition or GeneratorMethod then the representation must be such that if the string is evaluated, using eval in a lexical context that is equivalent to the lexical context used to create the original object, it will result in a new functionally equivalent object. In that case the returned source code must not mention freely any variables that were not mentioned freely by the original function's source code, even if these “extra” names were originally in scope.
If the 实现 cannot produce a source code string that meets these criteria then it must return a string for which eval will 抛出一个 SyntaxError 异常.

19.2.3.6Function.prototype [ @@hasInstance ] ( `V` )

When the @@hasInstance method of an object F is called with value V, 执行如下:

Let F be the this value.
Return ? OrdinaryHasInstance(F, V).

The value of the name property of this function is "[Symbol.hasInstance]".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

This is the default 实现 of @@hasInstance that most functions inherit. @@hasInstance is called by the instanceof 运算符 to determine whether a value is an instance of a specific 构造器. An expression 例如

v instanceof F

evaluates as

F[@@hasInstance](v)

A 构造器 function can control which objects are recognized as its instances by instanceof by exposing a different @@hasInstance method on the function.

This property is non-writable and non-configurable to prevent tampering that could be used to globally expose the target function of a bound function.

19.2.4Function 实例

每一个 Function 实例都是一个 ES 函数对象，和都有这些列在 Table 27 中内部属性。使用 Function.prototype.bind 方法创建的 Function 对象的内部属性列在 Table 28 中。

Function 实例有以下属性：

19.2.4.1length

The value of the length property is an integer that indicates the typical number of arguments expected by the function. However, the language permits the function to be invoked with some other number of arguments. The behaviour of a function when invoked on a number of arguments other than the number specified by its length property depends on the function. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.length 属性值是一个整数，它指出函数预期的参数个数。然而，语言允许用其他数量的参数来调用函数。当以与函数的 length 属性指定的数量不同的参数个数调用函数时，它的行为依赖于函数自身。这个属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }。

19.2.4.2name

The value of the name property is a String that is descriptive of the function. The name has no semantic significance but is typically a variable or 属性名 that is used to refer to the function at its point of definition in ES 代码. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

Anonymous functions objects that do not have a contextual name associated with them by this specification do not have a name 自身属性 but inherit the name property of %FunctionPrototype%.

19.2.4.3prototype

可以用来作为一个构造器的 Function 实例有一个 prototype 属性。Whenever such a Function instance is created another 普通对象 is also created and is the 初始值 of the function's prototype property. Unless otherwise specified, the value of the prototype property is used to initialize the [[Prototype]] 内部属性 of the object created when that function is invoked as a 构造器.

prototype 属性的值用于初始化一个新创建对象的的 [[Prototype]] 内部属性，为了这个新创建对象要先将函数对象作为构造器调用。

这个属性拥有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

函数对象 created using Function.prototype.bind, or by evaluating a MethodDefinition (that is not a GeneratorMethod or AsyncGeneratorMethod) or an ArrowFunction do not have a prototype property.

19.3Boolean 对象

19.3.1Boolean 构造器

The Boolean 构造器 is the %Boolean% 内部对象 and the 初始值 of the Boolean property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 Boolean 对象. When Boolean 被作为一个函数调用而不是一个构造器, 它会执行一个类型转换.

The Boolean 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Boolean behaviour must include a super call to the Boolean 构造器以便创建和初始化子类实例 with a [[BooleanData]] 内部属性.

19.3.1.1Boolean ( `value` )

When Boolean is called with argument value, 执行如下:

Let b be ToBoolean(value).
If NewTarget is undefined, return b.
Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%BooleanPrototype%", « [[BooleanData]] »).
Set O.[[BooleanData]] to b.
Return O.

19.3.2布尔构造器的属性

[[Prototype]] 内部属性的值 of the Boolean 构造器 is the 内部对象 %FunctionPrototype%.

The Boolean 构造器有以下属性:

19.3.2.1Boolean.prototype

The 初始值 of Boolean.prototype is the 内部对象 %BooleanPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.3.3布尔原型对象的属性

The Boolean 原型对象 is the 内部对象 %BooleanPrototype%. The Boolean 原型对象 is an 普通对象. The Boolean prototype is itself a Boolean 对象; it has a [[BooleanData]] 内部属性 with the value false.

[[Prototype]] 内部属性的值 of the Boolean 原型对象 is the 内部对象 %ObjectPrototype%.

The 抽象操作 thisBooleanValue(value) 执行如下:

If Type(value) is Boolean, return value.
If Type(value) is Object and value has a [[BooleanData]] 内部属性, then
1. Assert: value.[[BooleanData]] is a Boolean 值.
2. Return value.[[BooleanData]].
抛出一个 TypeError 异常.

19.3.3.1Boolean.prototype.constructor

The 初始值 of Boolean.prototype.constructor is the 内部对象 %Boolean%.

19.3.3.2Boolean.prototype.toString ( )

执行如下:

Let b be ? thisBooleanValue(this value).
If b is true, return "true"; else return "false".

19.3.3.3Boolean.prototype.valueOf ( )

执行如下:

Return ? thisBooleanValue(this value).

19.3.4布尔实例的属性

Boolean instances are 普通对象 that 继承属性 from the Boolean 原型对象. Boolean instances have a [[BooleanData]] 内部属性. The [[BooleanData]] 内部属性 is the Boolean 值 represented by this Boolean 对象.

19.4符号对象

19.4.1符号构造器

The Symbol 构造器 is the %Symbol% 内部对象 and the 初始值 of the Symbol property of the 全局对象. When Symbol is called as a function, it returns a new Symbol 值.

The Symbol 构造器 is not intended to be used with new 运算符 or to be subclassed. 它可以用作 the value of an extends clause of a class definition but a super call to the Symbol 构造器 will cause an 异常.

19.4.1.1Symbol ( [ `description` ] )

When Symbol is called with 可选参数 description, 执行如下:

If NewTarget is not undefined, 抛出一个 TypeError 异常.
If description is undefined, let descString be undefined.
Else, let descString be ? ToString(description).
Return a new unique Symbol 值 whose [[Description]] value is descString.

19.4.2符号构造器

[[Prototype]] 内部属性的值 of the Symbol 构造器 is the 内部对象 %FunctionPrototype%.

The Symbol 构造器有以下属性:

19.4.2.1Symbol.for ( `key` )

When Symbol.for is called with argument key it 执行如下:

Let stringKey be ? ToString(key).
For each element e of the GlobalSymbolRegistry List, do
1. If SameValue(e.[[Key]], stringKey) is true, return e.[[Symbol]].
Assert: GlobalSymbolRegistry does not currently contain an entry for stringKey.
Let newSymbol be a new unique Symbol 值 whose [[Description]] value is stringKey.
Append the Record { [[Key]]: stringKey, [[Symbol]]: newSymbol } to the GlobalSymbolRegistry List.
Return newSymbol.

The GlobalSymbolRegistry is a List that is globally available. It is shared by all 范围. Prior to the 估值 of any ES 代码 it is initialized as a new empty List. Elements of the GlobalSymbolRegistry are Records with the structure defined in Table 45.

Table 45: GlobalSymbolRegistry Record Fields

字段名	Value	Usage
[[Key]]	A String	A string key used to globally identify a Symbol.
[[Symbol]]	A Symbol	A symbol that can be retrieved from any realm.

19.4.2.2Symbol.asyncIterator

The 初始值 of Symbol.asyncIterator is the well known symbol @@asyncIterator (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.3Symbol.hasInstance

The 初始值 of Symbol.hasInstance is the 众所周知的符号 @@hasInstance (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.4Symbol.isConcatSpreadable

The 初始值 of Symbol.isConcatSpreadable is the 众所周知的符号 @@isConcatSpreadable (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.5Symbol.迭代器

The 初始值 of Symbol.迭代器 is the 众所周知的符号 @@迭代器 (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.6Symbol.keyFor ( `sym` )

When Symbol.keyFor is called with argument sym it 执行如下:

If Type(sym) is not Symbol, 抛出一个 TypeError 异常.
For each element e of the GlobalSymbolRegistry List (see 19.4.2.1), do
1. If SameValue(e.[[Symbol]], sym) is true, return e.[[Key]].
Assert: GlobalSymbolRegistry does not currently contain an entry for sym.
Return undefined.

19.4.2.7Symbol.match

The 初始值 of Symbol.match is the 众所周知的符号 @@match (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.8Symbol.prototype

The 初始值 of Symbol.prototype is the 内部对象 %SymbolPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.9Symbol.replace

The 初始值 of Symbol.replace is the 众所周知的符号 @@replace (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.10Symbol.search

The 初始值 of Symbol.search is the 众所周知的符号 @@search (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.11Symbol.species

The 初始值 of Symbol.species is the 众所周知的符号 @@species (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.12Symbol.split

The 初始值 of Symbol.split is the 众所周知的符号 @@split (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.13Symbol.toPrimitive

The 初始值 of Symbol.toPrimitive is the 众所周知的符号 @@toPrimitive (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.14Symbol.toStringTag

The 初始值 of Symbol.toStringTag is the 众所周知的符号 @@toStringTag (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.2.15Symbol.unscopables

The 初始值 of Symbol.unscopables is the 众所周知的符号 @@unscopables (Table 1).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.4.3符号原型对象的属性

The Symbol 原型对象 is the 内部对象 %SymbolPrototype%. The Symbol 原型对象 is an 普通对象. It is not a Symbol instance and does not have a [[SymbolData]] 内部属性.

[[Prototype]] 内部属性的值 of the Symbol 原型对象 is the 内部对象 %ObjectPrototype%.

The 抽象操作 thisSymbolValue(value) 执行如下:

If Type(value) is Symbol, return value.
If Type(value) is Object and value has a [[SymbolData]] 内部属性, then
1. Assert: value.[[SymbolData]] is a Symbol 值.
2. Return value.[[SymbolData]].
抛出一个 TypeError 异常.

19.4.3.1Symbol.prototype.constructor

The 初始值 of Symbol.prototype.constructor is the 内部对象 %Symbol%.

19.4.3.2Symbol.prototype.toString ( )

执行如下:

Let sym be ? thisSymbolValue(this value).
Return SymbolDescriptiveString(sym).

19.4.3.2.1运行时语义: SymbolDescriptiveString ( `sym` )

When the 抽象操作 SymbolDescriptiveString is called with argument sym, 执行如下:

Assert: Type(sym) is Symbol.
Let desc be sym's [[Description]] value.
If desc is undefined, let desc be the empty string.
Assert: Type(desc) is String.
Return the string-concatenation of "Symbol(", desc, and ")".

19.4.3.3Symbol.prototype.valueOf ( )

执行如下:

Return ? thisSymbolValue(this value).

19.4.3.4Symbol.prototype [ @@toPrimitive ] ( `hint` )

This function is called by ES language operators to convert a Symbol 对象 to a 原始值. The allowed values for hint are "default", "number", and "string".

When the @@toPrimitive method is called with argument hint, 执行如下:

Return ? thisSymbolValue(this value).

The value of the name property of this function is "[Symbol.toPrimitive]".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

19.4.3.5Symbol.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Symbol".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

19.4.4符号实例的属性

Symbol instances are 普通对象 that 继承属性 from the Symbol 原型对象. Symbol instances have a [[SymbolData]] 内部属性. The [[SymbolData]] 内部属性 is the Symbol 值 represented by this Symbol 对象.

19.5错误对象

Instances of 错误对象 are thrown as exceptions when runtime errors occur. The 错误对象 may also serve as base objects for user-defined 异常 classes.

19.5.1错误构造器

The Error 构造器 is the %Error% 内部对象 and the 初始值 of the Error property of the 全局对象. When Error 被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 Error object. Thus the function call Error(…) is equivalent to the object creation expression new Error(…) with the same arguments.

The Error 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Error behaviour must include a super call to the Error 构造器 to create and initialize subclass instances with an [[ErrorData]] 内部属性.

19.5.1.1Error ( `message` )

When the Error function is called with argument message, 执行如下:

If NewTarget is undefined, let newTarget be the active 函数对象, else let newTarget be NewTarget.
Let O be ? OrdinaryCreateFromConstructor(newTarget, "%ErrorPrototype%", « [[ErrorData]] »).
If message is not undefined, then
1. Let msg be ? ToString(message).
2. Let msgDesc be the PropertyDescriptor{[[Value]]: msg, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
3. Perform ! DefinePropertyOrThrow(O, "message", msgDesc).
Return O.

19.5.2错误构造器的属性

[[Prototype]] 内部属性的值 of the Error 构造器 is the 内部对象 %FunctionPrototype%.

The Error 构造器有以下属性:

19.5.2.1Error.prototype

The 初始值 of Error.prototype is the 内部对象 %ErrorPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.5.3错误原型对象的属性

The Error 原型对象 is the 内部对象 %ErrorPrototype%. The Error 原型对象 is an 普通对象. It is not an Error instance and does not have an [[ErrorData]] 内部属性.

[[Prototype]] 内部属性的值 of the Error 原型对象 is the 内部对象 %ObjectPrototype%.

19.5.3.1Error.prototype.constructor

The 初始值 of Error.prototype.constructor is the 内部对象 %Error%.

19.5.3.2Error.prototype.message

The 初始值 of Error.prototype.message is the empty String.

19.5.3.3Error.prototype.name

The 初始值 of Error.prototype.name is "Error".

19.5.3.4Error.prototype.toString ( )

执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
Let name be ? Get(O, "name").
If name is undefined, let name be "Error"; otherwise let name be ? ToString(name).
Let msg be ? Get(O, "message").
If msg is undefined, let msg be the empty String; otherwise let msg be ? ToString(msg).
If name is the empty String, return msg.
If msg is the empty String, return name.
Return the string-concatenation of name, the 代码单元 0x003A (COLON), the 代码单元 0x0020 (SPACE), and msg.

19.5.4错误实例的属性

Error instances are 普通对象 that 继承属性 from the Error 原型对象 and have an [[ErrorData]] 内部属性 whose value is undefined. The only specified uses of [[ErrorData]] is to identify Error and NativeError instances as 错误对象 within Object.prototype.toString.

19.5.5本标准使用的原生错误类型

A new instance of one of the NativeError objects below is thrown when a runtime error is detected. All of these objects share the same structure, as described in 19.5.6.

19.5.5.1EvalError

This 异常 is not currently used within this specification. This object remains for compatibility with previous editions of this specification.

19.5.5.2RangeError

Indicates a value that is not in the set or range of allowable values.

19.5.5.3ReferenceError

Indicate that an invalid reference value has been detected.

19.5.5.4SyntaxError

Indicates that a 解析错误 has occurred.

19.5.5.5TypeError

TypeError is used to indicate an unsuccessful operation when none of the other NativeError objects are an appropriate indication of the failure cause.

19.5.5.6URIError

Indicates that one of the global URI 处理函数 was used in a way that is incompatible with its definition.

19.5.6`NativeError` 对象结构

When an ES 实现 detects a runtime error, it throws a new instance of one of the NativeError objects defined in 19.5.5. Each of these objects has the structure described below, differing only in the name used as the 构造器 name instead of NativeError, in the name property of the 原型对象, and in the 实现-defined message property of the 原型对象.

For each error object, references to NativeError in the definition should be replaced with the appropriate error object name from 19.5.5.

19.5.6.1`NativeError` Constructors

When a NativeError 构造器被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 NativeError object. A call of the object as a function is equivalent to calling it as a 构造器 with the same arguments. Thus the function call NativeError(…) is equivalent to the object creation expression new NativeError(…) with the same arguments.

Each NativeError 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 NativeError behaviour must include a super call to the NativeError 构造器 to create and initialize subclass instances with an [[ErrorData]] 内部属性.

19.5.6.1.1NativeError ( `message` )

When a NativeError function is called with argument message, 执行如下:

If NewTarget is undefined, let newTarget be the active 函数对象, else let newTarget be NewTarget.
Let O be ? OrdinaryCreateFromConstructor(newTarget, "%NativeErrorPrototype%", « [[ErrorData]] »).
If message is not undefined, then
1. Let msg be ? ToString(message).
2. Let msgDesc be the PropertyDescriptor{[[Value]]: msg, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
3. Perform ! DefinePropertyOrThrow(O, "message", msgDesc).
Return O.

The actual value of the string passed in step 2 is either "%EvalErrorPrototype%", "%RangeErrorPrototype%", "%ReferenceErrorPrototype%", "%SyntaxErrorPrototype%", "%TypeErrorPrototype%", or "%URIErrorPrototype%" corresponding to which NativeError 构造器 is being defined.

19.5.6.2Properties of the `NativeError` Constructors

[[Prototype]] 内部属性的值 of a NativeError 构造器 is the 内部对象 %Error%.

Each NativeError 构造器 has a name property whose value is the String 值 `"NativeError"`.

Each NativeError 构造器有以下属性:

19.5.6.2.1NativeError.prototype

The 初始值 of NativeError.prototype is a NativeError 原型对象 (19.5.6.3). Each NativeError 构造器 has a distinct 原型对象.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

19.5.6.3Properties of the `NativeError` Prototype Objects

Each NativeError 原型对象 is an 普通对象. It is not an Error instance and does not have an [[ErrorData]] 内部属性.

[[Prototype]] 内部属性的值 of each NativeError 原型对象 is the 内部对象 %ErrorPrototype%.

19.5.6.3.1`NativeError`.prototype.constructor

The 初始值 of the 构造器 property of the prototype for a given NativeError 构造器 is the corresponding 内部对象 %NativeError% (19.5.6.1).

19.5.6.3.2`NativeError`.prototype.message

The 初始值 of the message property of the prototype for a given NativeError 构造器 is the empty String.

19.5.6.3.3`NativeError`.prototype.name

The 初始值 of the name property of the prototype for a given NativeError 构造器 is the String 值 consisting of the name of the 构造器 (the name used instead of NativeError).

19.5.6.4Properties of `NativeError` Instances

NativeError instances are 普通对象 that 继承属性 from their NativeError 原型对象 and have an [[ErrorData]] 内部属性 whose value is undefined. The only specified use of [[ErrorData]] is by Object.prototype.toString (19.1.3.6) to identify Error or NativeError instances.

20数字和日期

20.1Number 对象

20.1.1Number 构造器

Number 构造器是 %Number% 内部对象和全局对象的 Number 属性的初始值。当被作为一个构造器调用时，它会创建并初始化一个新的 Number 对象。当 Number 被作为一个函数而不是一个构造器被调用时，它会执行一个类型转换。

Number 构造器被设计为可被子类化的。它可以被用作一个类定义的 extends 语句的值。意图继承指定的 Number 对象行为的子类构造器必须包括一个 super 调用，以便于Number 构造器去创建和初始化一个带有 [[NumberData]] 内部属性的实例。

20.1.1.1Number ( `value` )

当用参数 valueNumber 调用时，执行如下：

如果没有参数被传递给该函数调用, let n be +0.
Else, let n be ? ToNumber(value).
If NewTarget is undefined, return n.
Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%NumberPrototype%", « [[NumberData]] »).
Set O.[[NumberData]] to n.
Return O.

20.1.2Number 构造器的属性

Number 构造器的 [[Prototype]] 内部属性的值是内部对象 %FunctionPrototype%。

Number 构造器存在下列属性：

20.1.2.1Number.EPSILON

The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number 值, which is approximately 2.2204460492503130808472633361816 x 10^-16.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.2Number.isFinite ( `number` )

当用参数 numberNumber.isFinite 调用时，执行如下：

If Type(number) is not Number, return false.
If number is NaN, +∞, or -∞, return false.
Otherwise, return true.

20.1.2.3Number.isInteger ( `number` )

当用参数 number 调用 Number.isInteger 时，执行如下：

If Type(number) is not Number, return false.
If number is NaN, +∞, or -∞, return false.
Let integer be ToInteger(number).
If integer is not equal to number, return false.
Otherwise, return true.

20.1.2.4Number.isNaN ( `number` )

当用参数 number 调用 Number.isNaN 时，执行如下：

If Type(number) is not Number, return false.
If number is NaN, return true.
Otherwise, return false.

Note

This function differs from the global isNaN function (18.2.3) in that it does not convert its argument to a Number before determining whether it is NaN.

20.1.2.5Number.isSafeInteger ( `number` )

当用参数 number 调用 Number.isSafeInteger 时，执行如下：

If Type(number) is not Number, return false.
If number is NaN, +∞, or -∞, return false.
Let integer be ToInteger(number).
If integer is not equal to number, return false.
If abs(integer) ≤ 2⁵³-1, return true.
Otherwise, return false.

20.1.2.6Number.MAX_SAFE_INTEGER

Note

The value of Number.MAX_SAFE_INTEGER is the largest integer n such that n and n + 1 are both exactly representable as a Number 值.

Number.MAX_SAFE_INTEGER 的值是 9007199254740991 (2⁵³-1)。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

20.1.2.7Number.MAX_VALUE

Number.MAX_VALUE 是 Number 类型中的最大的正有限值，约等于1.7976931348623157 × 10³⁰⁸。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.8Number.MIN_SAFE_INTEGER

Note

The value of Number.MIN_SAFE_INTEGER is the smallest integer n such that n and n - 1 are both exactly representable as a Number 值.

Number.MIN_SAFE_INTEGER 的值是 -9007199254740991 (-(2⁵³-1)).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.9Number.MIN_VALUE

Number.MIN_VALUE 是 Number 类型中的最小的正有限值，约等于 5 × 10^-324。

In the IEEE 754-2008 double precision binary representation, the smallest possible value is a denormalized number. If an 实现 does not support denormalized values, the value of Number.MIN_VALUE must be the smallest non-zero positive value that can actually be represented by the 实现.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.10Number.NaN

Number.NaN 的值是 NaN。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.11Number.NEGATIVE_INFINITY

Number.NEGATIVE_INFINITY 的值是 -∞。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.12Number.parseFloat ( `string` )

Number.parseFloat 数据属性的值与其对应内置函数对象的值（定义在 18.2.4 中的全局对象的 parseFloat 的值）一样。

20.1.2.13Number.parseInt ( `string`, `radix` )

Number.parseInt 数据属性的值与其对应内置函数对象的值（定义在 18.2.5 中的全局对象的 parseFloat 的值）一样。

20.1.2.14Number.POSITIVE_INFINITY

Number.POSITIVE_INFINITY 的值是 +∞。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.2.15Number.prototype

Number.prototype 的初始值是内部对象 %NumberPrototype%。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.1.3Number 原型对象的属性

Number 原型对象是内部对象 %NumberPrototype%。Number 原型对象是一个普通对象。Number prototype 本身是一个 Number 对象；它有一个值为 +0 的 [[NumberData]] 内部属性。

Number 原型对象的 [[Prototype]] 内部属性的值是内部对象 %ObjectPrototype%。

除非显示说明，否则以下定义的 Number 原型对象的方法不是一般的，且传递给它们的 this 值必须是一个 Number 值或是一个拥有 [[NumberData]] 内部属性且被初始化为一个 Number 值的对象。

抽象操作 thisNumberValue(value)执行如下：

If Type(value) is Number, return value.
If Type(value) is Object and value has a [[NumberData]] 内部属性, then
1. Assert: value.[[NumberData]] is a Number 值.
2. Return value.[[NumberData]].
抛出一个 TypeError 异常.

The phrase “this Number 值” within the specification of a method refers to the result returned by calling the 抽象操作 thisNumberValue with the this value of the method invocation passed as the argument.

20.1.3.1Number.prototype.constructor

Number.prototype.constructor 的初始值是内部对象 %Number%。

20.1.3.2Number.prototype.toExponential ( `fractionDigits` )

Return a String containing this Number 值 represented in decimal exponential notation with one digit before the significand's decimal point and fractionDigits digits after the significand's decimal point. If fractionDigits is undefined, include as many significand digits as necessary to uniquely specify the Number (just like in ToString except that in this case the Number is always output in exponential notation). Specifically, perform the following steps:

Let x be ? thisNumberValue(this value).
Let f be ? ToInteger(fractionDigits).
Assert: f is 0, when fractionDigits is undefined.
If x is NaN, return the String "NaN".
Let s be the empty String.
If x < 0, then
1. Let s be "-".
2. Let x be -x.
If x = +∞, then
1. Return the string-concatenation of s and "Infinity".
If f < 0 or f > 100, 抛出一个 RangeError 异常.
If x = 0, then
1. Let m be the String 值 consisting of f+1 occurrences of the 代码单元 0x0030 (DIGIT ZERO).
2. Let e be 0.
Else x ≠ 0,
1. If fractionDigits is not undefined, then
  1. Let e and n be integers such that 10^f ≤ n < 10^f+1 and for which the exact 数学值 of n × 10^e-f - x is as close to zero as possible. If there are two such sets of e and n, pick the e and n for which n × 10^e-f is larger.
2. Else fractionDigits is undefined,
  1. Let e, n, and f be integers such that f ≥ 0, 10^f ≤ n < 10^f+1, the Number 值 for n × 10^e-f is x, and f is as small as possible. Note that the decimal representation of n has f+1 digits, n is not divisible by 10, and the least significant digit of n is not necessarily uniquely determined by these criteria.
3. Let m be the String 值 consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
If f ≠ 0, then
1. Let a be the first element of m, and let b be the remaining f elements of m.
2. Let m be the string-concatenation of a, ".", and b.
If e = 0, then
1. Let c be "+".
2. Let d be "0".
Else,
1. If e > 0, let c be "+".
2. Else e ≤ 0,
  1. Let c be "-".
  2. Let e be -e.
3. Let d be the String 值 consisting of the digits of the decimal representation of e (in order, with no leading zeroes).
Let m be the string-concatenation of m, "e", c, and d.
Return the string-concatenation of s and m.

Note

For implementations that provide more accurate conversions than required by the rules above, it is recommended that the following alternative version of step 10.b.i be used as a guideline:

Let e, n, and f be integers such that f ≥ 0, 10^f ≤ n < 10^f+1, the Number 值 for n × 10^e-f is x, and f is as small as possible. If there are multiple possibilities for n, choose the value of n for which n × 10^e-f is closest in value to x. If there are two such possible values of n, choose the one that is even.

20.1.3.3Number.prototype.toFixed ( `fractionDigits` )

Note 1

toFixed returns a String containing this Number 值 represented in decimal fixed-point notation with fractionDigits digits after the decimal point. If fractionDigits is undefined, 0 is assumed.

The following steps are performed:

Let x be ? thisNumberValue(this value).
Let f be ? ToInteger(fractionDigits). (If fractionDigits is undefined, this step produces the value 0.)
If f < 0 or f > 100, 抛出一个 RangeError 异常.
If x is NaN, return the String "NaN".
Let s be the empty String.
If x < 0, then
1. Let s be "-".
2. Let x be -x.
If x ≥ 10²¹, then
1. Let m be ! ToString(x).
Else x < 10²¹,
1. Let n be an integer for which the exact 数学值 of n ÷ 10^f - x is as close to zero as possible. If there are two such n, pick the larger n.
2. If n = 0, let m be the String "0". Otherwise, let m be the String 值 consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
3. If f ≠ 0, then
  1. Let k be the length of m.
  2. If k ≤ f, then
    1. Let z be the String 值 consisting of f+1-k occurrences of the 代码单元 0x0030 (DIGIT ZERO).
    2. Let m be the string-concatenation of z and m.
    3. Let k be f + 1.
  3. Let a be the first k-f elements of m, and let b be the remaining f elements of m.
  4. Let m be the string-concatenation of a, ".", and b.
Return the string-concatenation of s and m.

Note 2

The output of toFixed may be more precise than toString for some values because toString only prints enough significant digits to distinguish the number from adjacent number values. 例如,

(1000000000000000128).toString() returns "1000000000000000100", while
(1000000000000000128).toFixed(0) returns "1000000000000000128".

20.1.3.4Number.prototype.toLocaleString ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the Number.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleString method is used.

Produces a String 值 that represents this Number 值 formatted according to the conventions of the host environment's current locale. This function is 实现-dependent, and it is permissible, but not encouraged, for it to return the same thing as toString.

The meanings of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.

20.1.3.5Number.prototype.toPrecision ( `precision` )

Return a String containing this Number 值 represented either in decimal exponential notation with one digit before the significand's decimal point and precision-1 digits after the significand's decimal point or in decimal fixed notation with precision significant digits. If precision is undefined, call ToString instead. Specifically, perform the following steps:

Let x be ? thisNumberValue(this value).
If precision is undefined, return ! ToString(x).
Let p be ? ToInteger(precision).
If x is NaN, return the String "NaN".
Let s be the empty String.
If x < 0, then
1. Let s be the 代码单元 0x002D (HYPHEN-MINUS).
2. Let x be -x.
If x = +∞, then
1. Return the string-concatenation of s and "Infinity".
If p < 1 or p > 100, 抛出一个 RangeError 异常.
If x = 0, then
1. Let m be the String 值 consisting of p occurrences of the 代码单元 0x0030 (DIGIT ZERO).
2. Let e be 0.
Else x ≠ 0,
1. Let e and n be integers such that 10^p-1 ≤ n < 10^p and for which the exact 数学值 of n × 10^e-p+1 - x is as close to zero as possible. If there are two such sets of e and n, pick the e and n for which n × 10^e-p+1 is larger.
2. Let m be the String 值 consisting of the digits of the decimal representation of n (in order, with no leading zeroes).
3. If e < -6 or e ≥ p, then
  1. Assert: e ≠ 0.
  2. If p ≠ 1, then
    1. Let a be the first element of m, and let b be the remaining p-1 elements of m.
    2. Let m be the string-concatenation of a, ".", and b.
  3. If e > 0, then
    1. Let c be the 代码单元 0x002B (PLUS SIGN).
  4. Else e < 0,
    1. Let c be the 代码单元 0x002D (HYPHEN-MINUS).
    2. Let e be -e.
  5. Let d be the String 值 consisting of the digits of the decimal representation of e (in order, with no leading zeroes).
  6. Return the string-concatenation of s, m, the 代码单元 0x0065 (LATIN SMALL LETTER E), c, and d.
If e = p-1, return the string-concatenation of s and m.
If e ≥ 0, then
1. Let m be the string-concatenation of the first e+1 elements of m, the 代码单元 0x002E (FULL STOP), and the remaining p- (e+1) elements of m.
Else e < 0,
1. Let m be the string-concatenation of the 代码单元 0x0030 (DIGIT ZERO), the 代码单元 0x002E (FULL STOP), -(e+1) occurrences of the 代码单元 0x0030 (DIGIT ZERO), and the String m.
Return the string-concatenation of s and m.

20.1.3.6Number.prototype.toString ( [ `radix` ] )

Note

The optional radix should be an integer value in the inclusive range 2 to 36. If radix is not present or is undefined the Number 10 is used as the value of radix.

The following steps are performed:

Let x be ? thisNumberValue(this value).
If radix is not present, let radixNumber be 10.
Else if radix is undefined, let radixNumber be 10.
Else, let radixNumber be ? ToInteger(radix).
If radixNumber < 2 or radixNumber > 36, 抛出一个 RangeError 异常.
If radixNumber = 10, return ! ToString(x).
Return the String representation of this Number 值 using the radix specified by radixNumber. Letters a-z are used for digits with values 10 through 35. The precise 算法 is 实现-dependent, however the 算法 should be a generalization of that specified in 7.1.12.1.

The toString function is not generic; it throws a TypeError 异常 if its this value is not a Number or a Number 对象. Therefore, it cannot be transferred to other kinds of objects for use as a method.

The length property of the toString method is 1.

20.1.3.7Number.prototype.valueOf ( )

Return ? thisNumberValue(this value).

20.1.4Number 实例属性

Number 实例是从 Number 原型对象上继承属性的普通对象。Number 实例也有 [[NumberValue]] 内部属性。[[NumberValue]] 内部属性是由 this Number 对象表示的 Number 值。

20.2Math 对象

Math 对象是 %Math% 内部对象和全局对象的 Math 属性的初始值。Math 对象是一个单一的普通对象。

Math 对象的 [[Prototype]] 内部属性的值是内部对象 %ObjectPrototype%。

Math 对象不是一个函数对象。它没有 [[Construct]] 内部方法；不能把 Math 对象作为一个构造器使用。Math 对象也没有 [[Call]] 内部方法；所以也不能把 Math 对象作为一个函数来调用。

Note

在本规范中，短语 “the Number 值 for x” 有一个技术上的含义（定义在 6.1.6）。

20.2.1Math 对象的值属性

20.2.1.1Math.E

数字值 e，是自然对数的底数，约为 2.7182818284590452354。

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.2Math.LN10

The Number 值 for the natural logarithm of 10, which is approximately 2.302585092994046.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }。

20.2.1.3Math.LN2

The Number 值 for the natural logarithm of 2, which is approximately 0.6931471805599453.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

20.2.1.4Math.LOG10E

The Number 值 for the base-10 logarithm of e, the base of the natural logarithms; this value is approximately 0.4342944819032518.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.LOG10E is approximately the reciprocal of the value of Math.LN10.

20.2.1.5Math.LOG2E

The Number 值 for the base-2 logarithm of e, the base of the natural logarithms; this value is approximately 1.4426950408889634.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.LOG2E is approximately the reciprocal of the value of Math.LN2.

20.2.1.6Math.PI

The Number 值 for π, the ratio of the circumference of a circle to its diameter, which is approximately 3.1415926535897932.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

20.2.1.7Math.SQRT1_2

The Number 值 for the square root of ½, which is approximately 0.7071067811865476.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

Note

The value of Math.SQRT1_2 is approximately the reciprocal of the value of Math.SQRT2.

20.2.1.8Math.SQRT2

The Number 值 for the square root of 2, which is approximately 1.4142135623730951.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

20.2.1.9Math [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Math".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

20.2.2Math 对象的函数属性

Each of the following Math object functions applies the ToNumber 抽象操作 to each of its arguments (in left-to-right order if there is more than one). If ToNumber returns an abrupt completion, that 完成记录 is immediately returned. Otherwise, the function performs a computation on the resulting Number 值(s). The value returned by each function is a Number.

In the function descriptions below, the symbols NaN, -0, +0, -∞ and +∞ refer to the Number values described in 6.1.6.

Note

The behaviour of the functions acos, acosh, asin, asinh, atan, atanh, atan2, cbrt, cos, cosh, exp, expm1, hypot, log,log1p, log2, log10, pow, random, sin, sinh, sqrt, tan, and tanh is not precisely specified here except to require specific results for certain argument values that represent boundary cases of interest. For other argument values, these functions are intended to compute approximations to the results of familiar 数学函数, but some latitude is allowed in the choice of approximation 算法. The general intent is that an implementer should be able to use the same mathematical library for ES on a given hardware platform that is available to C programmers on that platform.

Although the choice of 算法 is left to the 实现, it is recommended (but not specified by this standard) that implementations use the approximation 算法 for IEEE 754-2008 arithmetic contained in fdlibm, the freely distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).

20.2.2.1Math.abs ( `x` )

Returns the absolute value of x; the result has the same magnitude as x but has positive sign.

If x is NaN, the result is NaN.
If x is -0, the result is +0.
If x is -∞, the result is +∞.

20.2.2.2Math.acos ( `x` )

Returns an 实现-dependent approximation to the arc cosine of x. The result is expressed in radians and ranges from +0 to +π.

If x is NaN, the result is NaN.
If x is greater than 1, the result is NaN.
If x is less than -1, the result is NaN.
If x is exactly 1, the result is +0.

20.2.2.3Math.acosh ( `x` )

Returns an 实现-dependent approximation to the inverse hyperbolic cosine of x.

If x is NaN, the result is NaN.
If x is less than 1, the result is NaN.
If x is 1, the result is +0.
If x is +∞, the result is +∞.

20.2.2.4Math.asin ( `x` )

Returns an 实现-dependent approximation to the arc sine of x. The result is expressed in radians and ranges from -π/2 to +π/2.

If x is NaN, the result is NaN.
If x is greater than 1, the result is NaN.
If x is less than -1, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.

20.2.2.5Math.asinh ( `x` )

Returns an 实现-dependent approximation to the inverse hyperbolic sine of x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.

20.2.2.6Math.atan ( `x` )

Returns an 实现-dependent approximation to the arc tangent of x. The result is expressed in radians and ranges from -π/2 to +π/2.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is an 实现-dependent approximation to +π/2.
If x is -∞, the result is an 实现-dependent approximation to -π/2.

20.2.2.7Math.atanh ( `x` )

Returns an 实现-dependent approximation to the inverse hyperbolic tangent of x.

If x is NaN, the result is NaN.
If x is less than -1, the result is NaN.
If x is greater than 1, the result is NaN.
If x is -1, the result is -∞.
If x is +1, the result is +∞.
If x is +0, the result is +0.
If x is -0, the result is -0.

20.2.2.8Math.atan2 ( `y`, `x` )

Returns an 实现-dependent approximation to the arc tangent of the quotient y/x of the arguments y and x, where the signs of y and x are used to determine the quadrant of the result. Note that it is intentional and traditional for the two-argument arc tangent function that the argument named y be first and the argument named x be second. The result is expressed in radians and ranges from -π to +π.

If either x or y is NaN, the result is NaN.
If y>0 and x is +0, the result is an 实现-dependent approximation to +π/2.
If y>0 and x is -0, the result is an 实现-dependent approximation to +π/2.
If y is +0 and x>0, the result is +0.
If y is +0 and x is +0, the result is +0.
If y is +0 and x is -0, the result is an 实现-dependent approximation to +π.
If y is +0 and x<0, the result is an 实现-dependent approximation to +π.
If y is -0 and x>0, the result is -0.
If y is -0 and x is +0, the result is -0.
If y is -0 and x is -0, the result is an 实现-dependent approximation to -π.
If y is -0 and x<0, the result is an 实现-dependent approximation to -π.
If y<0 and x is +0, the result is an 实现-dependent approximation to -π/2.
If y<0 and x is -0, the result is an 实现-dependent approximation to -π/2.
If y>0 and y is finite and x is +∞, the result is +0.
If y>0 and y is finite and x is -∞, the result is an 实现-dependent approximation to +π.
If y<0 and y is finite and x is +∞, the result is -0.
If y<0 and y is finite and x is -∞, the result is an 实现-dependent approximation to -π.
If y is +∞ and x is finite, the result is an 实现-dependent approximation to +π/2.
If y is -∞ and x is finite, the result is an 实现-dependent approximation to -π/2.
If y is +∞ and x is +∞, the result is an 实现-dependent approximation to +π/4.
If y is +∞ and x is -∞, the result is an 实现-dependent approximation to +3π/4.
If y is -∞ and x is +∞, the result is an 实现-dependent approximation to -π/4.
If y is -∞ and x is -∞, the result is an 实现-dependent approximation to -3π/4.

20.2.2.9Math.cbrt ( `x` )

Returns an 实现-dependent approximation to the cube root of x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.

20.2.2.10Math.ceil ( `x` )

Returns the smallest (closest to -∞) Number 值 that is not less than x and is equal to a mathematical integer. If x is already an integer, the result is x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.
If x is less than 0 but greater than -1, the result is -0.

The value of Math.ceil(x) is the same as the value of -Math.floor(-x).

20.2.2.11Math.clz32 ( `x` )

When Math.clz32 is called with one argument x, 执行如下:

Let n be ToUint32(x).
Let p be the number of leading zero bits in the 32-bit binary representation of n.
Return p.

Note

If n is 0, p will be 32. If the most significant bit of the 32-bit binary encoding of n is 1, p will be 0.

20.2.2.12Math.cos ( `x` )

Returns an 实现-dependent approximation to the cosine of x. The argument is expressed in radians.

If x is NaN, the result is NaN.
If x is +0, the result is 1.
If x is -0, the result is 1.
If x is +∞, the result is NaN.
If x is -∞, the result is NaN.

20.2.2.13Math.cosh ( `x` )

Returns an 实现-dependent approximation to the hyperbolic cosine of x.

If x is NaN, the result is NaN.
If x is +0, the result is 1.
If x is -0, the result is 1.
If x is +∞, the result is +∞.
If x is -∞, the result is +∞.

Note

The value of cosh(x) is the same as (exp(x) + exp(-x))/2.

20.2.2.14Math.exp ( `x` )

Returns an 实现-dependent approximation to the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms).

If x is NaN, the result is NaN.
If x is +0, the result is 1.
If x is -0, the result is 1.
If x is +∞, the result is +∞.
If x is -∞, the result is +0.

20.2.2.15Math.expm1 ( `x` )

Returns an 实现-dependent approximation to subtracting 1 from the exponential function of x (e raised to the power of x, where e is the base of the natural logarithms). The result is computed in a way that is accurate even when the value of x is close 0.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -1.

20.2.2.16Math.floor ( `x` )

Returns the greatest (closest to +∞) Number 值 that is not greater than x and is equal to a mathematical integer. If x is already an integer, the result is x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.
If x is greater than 0 but less than 1, the result is +0.

Note

The value of Math.floor(x) is the same as the value of -Math.ceil(-x).

20.2.2.17Math.fround ( `x` )

When Math.fround is called with argument x, 执行如下:

If x is NaN, return NaN.
If x is one of +0, -0, +∞, -∞, return x.
Let x32 be the result of converting x to a value in IEEE 754-2008 binary32 format using roundTiesToEven.
Let x64 be the result of converting x32 to a value in IEEE 754-2008 binary64 format.
Return the ES Number 值 corresponding to x64.

20.2.2.18Math.hypot ( `value1`, `value2`, ...`values` )

Math.hypot returns an 实现-dependent approximation of the square root of the sum of squares of its arguments.

If no arguments are passed, the result is +0.
If any argument is +∞, the result is +∞.
If any argument is -∞, the result is +∞.
If no argument is +∞ or -∞, and any argument is NaN, the result is NaN.
If all arguments are either +0 or -0, the result is +0.

Note

Implementations should take care to avoid the loss of precision from overflows and underflows that are prone to occur in naive implementations when this function is called with two or more arguments.

20.2.2.19Math.imul ( `x`, `y` )

When Math.imul is called with arguments x and y, 执行如下:

Let a be ToUint32(x).
Let b be ToUint32(y).
Let product be (a × b) modulo 2³².
If product ≥ 2³¹, return product - 2³²; otherwise return product.

20.2.2.20Math.log ( `x` )

Returns an 实现-dependent approximation to the natural logarithm of x.

If x is NaN, the result is NaN.
If x is less than 0, the result is NaN.
If x is +0 or -0, the result is -∞.
If x is 1, the result is +0.
If x is +∞, the result is +∞.

20.2.2.21Math.log1p ( `x` )

Returns an 实现-dependent approximation to the natural logarithm of 1 + x. The result is computed in a way that is accurate even when the value of x is close to zero.

If x is NaN, the result is NaN.
If x is less than -1, the result is NaN.
If x is -1, the result is -∞.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.

20.2.2.22Math.log10 ( `x` )

Returns an 实现-dependent approximation to the base 10 logarithm of x.

If x is NaN, the result is NaN.
If x is less than 0, the result is NaN.
If x is +0, the result is -∞.
If x is -0, the result is -∞.
If x is 1, the result is +0.
If x is +∞, the result is +∞.

20.2.2.23Math.log2 ( `x` )

Returns an 实现-dependent approximation to the base 2 logarithm of x.

If x is NaN, the result is NaN.
If x is less than 0, the result is NaN.
If x is +0, the result is -∞.
If x is -0, the result is -∞.
If x is 1, the result is +0.
If x is +∞, the result is +∞.

20.2.2.24Math.max ( `value1`, `value2`, ...`values` )

Given zero or more arguments, calls ToNumber on each of the arguments and returns the largest of the resulting values.

If no arguments are given, the result is -∞.
If any value is NaN, the result is NaN.
The comparison of values to determine the largest value is done using the 抽象关系比较算法 except that +0 is considered to be larger than -0.

20.2.2.25Math.min ( `value1`, `value2`, ...`values` )

Given zero or more arguments, calls ToNumber on each of the arguments and returns the smallest of the resulting values.

If no arguments are given, the result is +∞.
If any value is NaN, the result is NaN.
The comparison of values to determine the smallest value is done using the 抽象关系比较算法 except that +0 is considered to be larger than -0.

20.2.2.26Math.pow ( `base`, `exponent` )

Return the result of Applying the ** 运算符 with base and exponent as specified in 12.6.4.

20.2.2.27Math.random ( )

Returns a Number 值 with positive sign, greater than or equal to 0 but less than 1, chosen randomly or pseudo randomly with approximately uniform distribution over that range, using an 实现-dependent 算法 or strategy. This function takes no arguments.

Each Math.random function created for distinct 范围 must produce a distinct sequence of values from successive calls.

20.2.2.28Math.round ( `x` )

Returns the Number 值 that is closest to x and is equal to a mathematical integer. If two integer Number values are equally close to x, then the result is the Number 值 that is closer to +∞. If x is already an integer, the result is x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.
If x is greater than 0 but less than 0.5, the result is +0.
If x is less than 0 but greater than or equal to -0.5, the result is -0.

Note 1

Math.round(3.5) returns 4, but Math.round(-3.5) returns -3.

Note 2

The value of Math.round(x) is not always the same as the value of Math.floor(x+0.5). When x is -0 or is less than 0 but greater than or equal to -0.5, Math.round(x) returns -0, but Math.floor(x+0.5) returns +0. Math.round(x) may also differ from the value of Math.floor(x+0.5)because of internal rounding when computing x+0.5.

20.2.2.29Math.sign ( `x` )

Returns the sign of x, indicating whether x is positive, negative, or zero.

If x is NaN, the result is NaN.
If x is -0, the result is -0.
If x is +0, the result is +0.
If x is negative and not -0, the result is -1.
If x is positive and not +0, the result is +1.

20.2.2.30Math.sin ( `x` )

Returns an 实现-dependent approximation to the sine of x. The argument is expressed in radians.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞ or -∞, the result is NaN.

20.2.2.31Math.sinh ( `x` )

Returns an 实现-dependent approximation to the hyperbolic sine of x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.

Note

The value of sinh(x) is the same as (exp(x) - exp(-x))/2.

20.2.2.32Math.sqrt ( `x` )

Returns an 实现-dependent approximation to the square root of x.

If x is NaN, the result is NaN.
If x is less than 0, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +∞.

20.2.2.33Math.tan ( `x` )

Returns an 实现-dependent approximation to the tangent of x. The argument is expressed in radians.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞ or -∞, the result is NaN.

20.2.2.34Math.tanh ( `x` )

Returns an 实现-dependent approximation to the hyperbolic tangent of x.

If x is NaN, the result is NaN.
If x is +0, the result is +0.
If x is -0, the result is -0.
If x is +∞, the result is +1.
If x is -∞, the result is -1.

Note

The value of tanh(x) is the same as (exp(x) - exp(-x))/(exp(x) + exp(-x)).

20.2.2.35Math.trunc ( `x` )

Returns the integral part of the number x, removing any fractional digits. If x is already an integer, the result is x.

If x is NaN, the result is NaN.
If x is -0, the result is -0.
If x is +0, the result is +0.
If x is +∞, the result is +∞.
If x is -∞, the result is -∞.
If x is greater than 0 but less than 1, the result is +0.
If x is less than 0 but greater than -1, the result is -0.

20.3Date 对象

20.3.1Date 对象的概述和抽象操作的定义

The following functions are 抽象操作 that operate on time values (defined in 20.3.1.1). Note that, in every case, if any argument to one of these functions is NaN, the result will be NaN.

20.3.1.1时间值和时间范围

A Date object contains a Number indicating a particular instant in time to within a millisecond. Such a Number is called a time value. A time value may also be NaN, indicating that the Date object does not represent a specific instant of time.

Time is measured in ES in milliseconds since 01 January, 1970 UTC. In time values leap seconds are ignored. It is assumed that there are exactly 86,400,000 milliseconds per day. ES Number values can represent all integers from -9,007,199,254,740,992 to 9,007,199,254,740,992; this range suffices to measure times to millisecond precision for any instant that is within approximately 285,616 years, either forward or backward, from 01 January, 1970 UTC.

The actual range of times supported by ES 日期对象 is slightly smaller: exactly -100,000,000 days to 100,000,000 days measured relative to midnight at the beginning of 01 January, 1970 UTC. This gives a range of 8,640,000,000,000,000 milliseconds to either side of 01 January, 1970 UTC.

The exact moment of midnight at the beginning of 01 January, 1970 UTC is represented by the value +0.

20.3.1.2Day Number and Time within Day

A given time value t belongs to day number

Day(t) = floor(t / msPerDay)

where the number of milliseconds per day is

msPerDay = 86400000

The remainder is called the time within the day:

TimeWithinDay(t) = t

modulo

msPerDay

20.3.1.3Year Number

ES uses a proleptic Gregorian calendar to map a day number to a year number and to determine the month and date within that year. In this calendar, leap years are precisely those which are (divisible by 4) and ((not divisible by 100) or (divisible by 400)). The number of days in year number y is therefore defined by

DaysInYear(y)

= 365 if (y modulo 4) ≠ 0

= 366 if (y modulo 4) = 0 and (y modulo 100) ≠ 0

= 365 if (y modulo 100) = 0 and (y modulo 400) ≠ 0

= 366 if (y modulo 400) = 0

All non-leap years have 365 days with the usual number of days per month and leap years have an extra day in February. The day number of the first day of year y is given by:

DayFromYear(y) = 365 × (y-1970) + floor((y-1969)/4) - floor((y-1901)/100) + floor((y-1601)/400)

The time value of the start of a year is:

TimeFromYear(y) = msPerDay × DayFromYear(y)

A time value determines a year by:

YearFromTime(t) = the largest integer y (closest to 正无穷) such that TimeFromYear(y) ≤ t

The leap-year function is 1 for a time within a leap year and otherwise is zero:

InLeapYear(t)

= 0 if DaysInYear(YearFromTime(t)) = 365

= 1 if DaysInYear(YearFromTime(t)) = 366

20.3.1.4Month Number

Months are identified by an integer in the range 0 to 11, inclusive. The mapping MonthFromTime(t) from a time value t to a month number is defined by:

MonthFromTime(t)

= 0 if 0 ≤ DayWithinYear(t) < 31

= 1 if 31 ≤ DayWithinYear(t) < 59+InLeapYear(t)

= 2 if 59+InLeapYear(t) ≤ DayWithinYear(t) < 90+InLeapYear(t)

= 3 if 90+InLeapYear(t) ≤ DayWithinYear(t) < 120+InLeapYear(t)

= 4 if 120+InLeapYear(t) ≤ DayWithinYear(t) < 151+InLeapYear(t)

= 5 if 151+InLeapYear(t) ≤ DayWithinYear(t) < 181+InLeapYear(t)

= 6 if 181+InLeapYear(t) ≤ DayWithinYear(t) < 212+InLeapYear(t)

= 7 if 212+InLeapYear(t) ≤ DayWithinYear(t) < 243+InLeapYear(t)

= 8 if 243+InLeapYear(t) ≤ DayWithinYear(t) < 273+InLeapYear(t)

= 9 if 273+InLeapYear(t) ≤ DayWithinYear(t) < 304+InLeapYear(t)

= 10 if 304+InLeapYear(t) ≤ DayWithinYear(t) < 334+InLeapYear(t)

= 11 if 334+InLeapYear(t) ≤ DayWithinYear(t) < 365+InLeapYear(t)

where

DayWithinYear(t) = Day(t)-DayFromYear(YearFromTime(t))

A month value of 0 specifies January; 1 specifies February; 2 specifies March; 3 specifies April; 4 specifies May; 5 specifies June; 6 specifies July; 7 specifies August; 8 specifies September; 9 specifies October; 10 specifies November; and 11 specifies December. Note that MonthFromTime(0) = 0, corresponding to Thursday, 01 January, 1970.

20.3.1.5Date Number

A date number is identified by an integer in the range 1 through 31, inclusive. The mapping DateFromTime(t) from a time value t to a date number is defined by:

DateFromTime(t)

= DayWithinYear(t)+1 if MonthFromTime(t)=0

= DayWithinYear(t)-30 if MonthFromTime(t)=1

= DayWithinYear(t)-58-InLeapYear(t) if MonthFromTime(t)=2

= DayWithinYear(t)-89-InLeapYear(t) if MonthFromTime(t)=3

= DayWithinYear(t)-119-InLeapYear(t) if MonthFromTime(t)=4

= DayWithinYear(t)-150-InLeapYear(t) if MonthFromTime(t)=5

= DayWithinYear(t)-180-InLeapYear(t) if MonthFromTime(t)=6

= DayWithinYear(t)-211-InLeapYear(t) if MonthFromTime(t)=7

= DayWithinYear(t)-242-InLeapYear(t) if MonthFromTime(t)=8

= DayWithinYear(t)-272-InLeapYear(t) if MonthFromTime(t)=9

= DayWithinYear(t)-303-InLeapYear(t) if MonthFromTime(t)=10

= DayWithinYear(t)-333-InLeapYear(t) if MonthFromTime(t)=11

20.3.1.6Week Day

The weekday for a particular time value t is defined as

WeekDay(t) = (Day(t) + 4) modulo 7

A weekday value of 0 specifies Sunday; 1 specifies Monday; 2 specifies Tuesday; 3 specifies Wednesday; 4 specifies Thursday; 5 specifies Friday; and 6 specifies Saturday. Note that WeekDay(0) = 4, corresponding to Thursday, 01 January, 1970.

20.3.1.7LocalTZA ( `t`, `isUTC` )

LocalTZA( t, isUTC ) is an 实现-defined 算法 that must return a number representing milliseconds suitable for adding to a Time Value. The local political rules for standard time and daylight saving time in effect at t should be used to determine the result in the way specified in the following three paragraphs.

When isUTC is true, LocalTZA( t, true ) should return the offset of the local time zone from UTC measured in milliseconds at time represented by time value t (UTC). When the result is added to t (UTC), it should yield the local time.

When isUTC is false, LocalTZA( t, false ) should return the offset of the local time zone from UTC measured in milliseconds at local time represented by time value t_local = t. When the result is subtracted from the local time t_local, it should yield the corresponding UTC.

When t_local represents local time repeating multiple times at a negative time zone transition (e.g. when the daylight saving time ends or the time zone adjustment is decreased due to a time zone rule change) or skipped local time at a positive time zone transitions (e.g. when the daylight saving time starts or the time zone adjustment is increased due to a time zone rule change), t_local must be interpreted with the time zone adjustment before the transition.

If an 实现 does not support a conversion described above or if political rules for time t are not available within the 实现, the result must be 0.

Note

It is recommended that implementations use the time zone information of the IANA Time Zone Database https://www.iana.org/time-zones/.

1:30 AM on November 5, 2017 in America/New_York is repeated twice (fall backward), but it must be interpreted as 1:30 AM UTC-04 instead of 1:30 AM UTC-05. LocalTZA(TimeClip(MakeDate(MakeDay(2017, 10, 5), MakeTime(1, 30, 0, 0))), false) is -4 × msPerHour.

2:30 AM on March 12, 2017 in America/New_York does not exist, but it must be interpreted as 2:30 AM UTC-05 (equivalent to 3:30 AM UTC-04). LocalTZA(TimeClip(MakeDate(MakeDay(2017, 2, 12), MakeTime(2, 30, 0, 0))), false) is -5 × msPerHour.

20.3.1.8LocalTime ( `t` )

The 抽象操作 LocalTime with argument t converts t from UTC to local time by performing the following steps:

Return t + LocalTZA(t, true).

Note

Two different time values (t (UTC)) are converted to the same local time t_local at a negative time zone transition when there are repeated times (e.g. the daylight saving time ends or the time zone adjustment is decreased.).

20.3.1.9UTC ( `t` )

The 抽象操作 UTC with argument t converts t from local time to UTC. It 执行如下:

Return t - LocalTZA(t, false).

Note

UTC(LocalTime(t)) is not necessarily always equal to t. LocalTime(UTC(t_local)) is not necessarily always equal to t_local, either.

20.3.1.10Hours, Minutes, Second, and Milliseconds

The following 抽象操作 are useful in decomposing time values:

HourFromTime(t) = floor(t / msPerHour) modulo

HoursPerDay

MinFromTime(t) = floor(t / msPerMinute) modulo

MinutesPerHour

SecFromTime(t) = floor(t / msPerSecond) modulo

SecondsPerMinute

msFromTime(t) = t

modulo

msPerSecond

where

HoursPerDay = 24

MinutesPerHour = 60

SecondsPerMinute = 60

msPerSecond = 1000

msPerMinute = 60000 = msPerSecond × SecondsPerMinute

msPerHour = 3600000 = msPerMinute × MinutesPerHour

20.3.1.11MakeTime ( `hour`, `min`, `sec`, `ms` )

The 抽象操作 MakeTime calculates a number of milliseconds from its four arguments, which must be ES Number values. This 运算符 functions as follows:

If hour is not finite or min is not finite or sec is not finite or ms is not finite, return NaN.
Let h be ! ToInteger(hour).
Let m be ! ToInteger(min).
Let s be ! ToInteger(sec).
Let milli be ! ToInteger(ms).
Let t be h * msPerHour + m * msPerMinute + s * msPerSecond + milli, performing the arithmetic according to IEEE 754-2008 rules (that is, as if using the ES operators * and +).
Return t.

20.3.1.12MakeDay ( `year`, `month`, `date` )

The 抽象操作 MakeDay calculates a number of days from its three arguments, which must be ES Number values. This 运算符 functions as follows:

If year is not finite or month is not finite or date is not finite, return NaN.
Let y be ! ToInteger(year).
Let m be ! ToInteger(month).
Let dt be ! ToInteger(date).
Let ym be y + floor(m / 12).
Let mn be m modulo 12.
Find a value t such that YearFromTime(t) is ym and MonthFromTime(t) is mn and DateFromTime(t) is 1; but if this is not possible (because some argument is out of range), return NaN.
Return Day(t) + dt - 1.

20.3.1.13MakeDate ( `day`, `time` )

The 抽象操作 MakeDate calculates a number of milliseconds from its two arguments, which must be ES Number values. This 运算符 functions as follows:

If day is not finite or time is not finite, return NaN.
Return day × msPerDay + time.

20.3.1.14TimeClip ( `time` )

The 抽象操作 TimeClip calculates a number of milliseconds from its argument, which must be an ES Number 值. This 运算符 functions as follows:

If time is not finite, return NaN.
If abs(time) > 8.64 × 10¹⁵, return NaN.
Let clippedTime be ! ToInteger(time).
If clippedTime is -0, set clippedTime to +0.
Return clippedTime.

Note

The point of step 4 is that an 实现 is permitted a choice of internal representations of time values, 例如 as a 64-bit signed integer or as a 64-bit floating-point value. Depending on the 实现, this internal representation may or may not distinguish -0 and +0.

20.3.1.15Date Time String Format

ES defines a string interchange format for date-times based upon a simplification of the ISO 8601 Extended Format. The format is as follows: YYYY-MM-DDTHH:mm:ss.sssZ

Where the fields are as follows:

`YYYY`	is the decimal digits of the year 0000 to 9999 in the proleptic Gregorian calendar.
`-`	`"-"` (hyphen) appears literally twice in the string.
`MM`	is the month of the year from 01 (January) to 12 (December).
`DD`	is the day of the month from 01 to 31.
`T`	`"T"` appears literally in the string, to indicate the beginning of the time element.
`HH`	is the number of complete hours that have passed since midnight as two decimal digits from 00 to 24.
`:`	`":"` (colon) appears literally twice in the string.
`mm`	is the number of complete minutes since the start of the hour as two decimal digits from 00 to 59.
`ss`	is the number of complete seconds since the start of the minute as two decimal digits from 00 to 59.
`.`	`"."` (dot) appears literally in the string.
`sss`	is the number of complete milliseconds since the start of the second as three decimal digits.
`Z`	is the time zone offset specified as `"Z"` (for UTC) or either `"+"` or `"-"` followed by a time expression `HH:mm`

This format includes date-only forms:

YYYY
                      YYYY-MM
                      YYYY-MM-DD

It also includes “date-time” forms that consist of one of the above date-only forms immediately followed by one of the following time forms with an optional time zone offset appended:

THH:mm
                      THH:mm:ss
                      THH:mm:ss.sss

All numbers must be base 10. If the MM or DD fields are absent "01" is used as the value. If the HH, mm, or ss fields are absent "00" is used as the value and the value of an absent sss field is "000". When the time zone offset is absent, date-only forms are interpreted as a UTC time and date-time forms are interpreted as a local time.

Illegal values (out-of-bounds as well as syntax errors) in a format string means that the format string is not a valid instance of this format.

Note 1

As every day both starts and ends with midnight, the two notations 00:00 and 24:00 are available to distinguish the two midnights that can be associated with one date. This means that the following two notations refer to exactly the same point in time: 1995-02-04T24:00 and 1995-02-05T00:00

Note 2

There exists no international standard that specifies abbreviations for civil time zones like CET, EST, etc. and sometimes the same abbreviation is even used for two very different time zones. For this reason, ISO 8601 and this format specifies numeric representations of date and time.

20.3.1.15.1Extended Years

ES requires the ability to specify 6 digit years (extended years); approximately 285,426 years, either forward or backward, from 01 January, 1970 UTC. To represent years before 0 or after 9999, ISO 8601 permits the expansion of the year representation, but only by prior agreement between the sender and the receiver. In the simplified ES format such an expanded year representation shall have 2 extra year digits and is always prefixed with a + or - sign. The year 0 is considered positive and hence prefixed with a + sign.

Note

Examples of extended years:

-283457-03-21T15:00:59.008Z	283458 B.C.
-000001-01-01T00:00:00Z	2 B.C.
+000000-01-01T00:00:00Z	1 B.C.
+000001-01-01T00:00:00Z	1 A.D.
+001970-01-01T00:00:00Z	1970 A.D.
+002009-12-15T00:00:00Z	2009 A.D.
+287396-10-12T08:59:00.992Z	287396 A.D.

20.3.2Date 构造器

The Date 构造器 is the %Date% 内部对象 and the 初始值 of the Date property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 Date object. When Date 被作为一个函数调用而不是一个构造器, it returns a String representing the current time (UTC).

The Date 构造器 is a single function whose behaviour is overloaded based upon the number and types of its arguments.

The Date 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Date behaviour must include a super call to the Date 构造器以便创建和初始化子类实例 with a [[DateValue]] 内部属性.

The length property of the Date 构造器 function is 7.

20.3.2.1Date ( `year`, `month` [ , `date` [ , `hours` [ , `minutes` [ , `seconds` [ , `ms` ] ] ] ] ] )

This description applies only if the Date 构造器 is called with at least two arguments.

When the Date function is called, 执行如下:

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs ≥ 2.
If NewTarget is undefined, then
1. Let now be the Number that is the time value (UTC) identifying the current time.
2. Return ToDateString(now).
Else,
1. Let y be ? ToNumber(year).
2. Let m be ? ToNumber(month).
3. If date is present, let dt be ? ToNumber(date); else let dt be 1.
4. If hours is present, let h be ? ToNumber(hours); else let h be 0.
5. If minutes is present, let min be ? ToNumber(minutes); else let min be 0.
6. If seconds is present, let s be ? ToNumber(seconds); else let s be 0.
7. If ms is present, let milli be ? ToNumber(ms); else let milli be 0.
8. If y is not NaN and 0 ≤ ToInteger(y) ≤ 99, let yr be 1900+ToInteger(y); otherwise, let yr be y.
9. Let finalDate be MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli)).
10. Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%DatePrototype%", « [[DateValue]] »).
11. Set O.[[DateValue]] to TimeClip(UTC(finalDate)).
12. Return O.

20.3.2.2Date ( `value` )

This description applies only if the Date 构造器 is called with exactly one argument.

When the Date function is called, 执行如下:

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs = 1.
If NewTarget is undefined, then
1. Let now be the Number that is the time value (UTC) identifying the current time.
2. Return ToDateString(now).
Else,
1. If Type(value) is Object and value has a [[DateValue]] 内部属性, then
  1. Let tv be thisTimeValue(value).
2. Else,
  1. Let v be ? ToPrimitive(value).
  2. If Type(v) is String, then
    1. Let tv be the result of parsing v as a date, in exactly the same manner as for the parse method (20.3.3.2). If the parse resulted in an abrupt completion, tv is the 完成记录.
    2. ReturnIfAbrupt(tv).
  3. Else,
    1. Let tv be ? ToNumber(v).
3. Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%DatePrototype%", « [[DateValue]] »).
4. Set O.[[DateValue]] to TimeClip(tv).
5. Return O.

20.3.2.3Date ( )

This description applies only if the Date 构造器 is called with no arguments.

When the Date function is called, 执行如下:

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs = 0.
If NewTarget is undefined, then
1. Let now be the Number that is the time value (UTC) identifying the current time.
2. Return ToDateString(now).
Else,
1. Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%DatePrototype%", « [[DateValue]] »).
2. Set O.[[DateValue]] to the time value (UTC) identifying the current time.
3. Return O.

20.3.3Date 构造器的属性

[[Prototype]] 内部属性的值 of the Date 构造器 is the 内部对象 %FunctionPrototype%.

The Date 构造器有以下属性:

20.3.3.1Date.now ( )

The now function returns a Number 值 that is the time value designating the UTC date and time of the occurrence of the call to now.

20.3.3.2Date.parse ( `string` )

The parse function applies the ToString 运算符 to its argument. If ToString results in an abrupt completion the 完成记录 is immediately returned. Otherwise, parse interprets the resulting String as a date and time; it returns a Number, the UTC time value corresponding to the date and time. The String may be interpreted as a local time, a UTC time, or a time in some other time zone, depending on the contents of the String. The function first attempts to parse the format of the String according to the rules (including extended years) called out in Date Time String Format (20.3.1.15). If the String does not conform to that format the function may fall back to any 实现-specific heuristics or 实现-specific date formats. Unrecognizable Strings or dates containing illegal element values in the format String shall cause Date.parse to return NaN.

If x is any Date object whose milliseconds amount is zero within a particular 实现 of ES, then all of the following expressions should produce the same 数字值 in that 实现, if all the properties referenced have their initial values:

x.valueOf()
                      Date.parse(x.toString())
                      Date.parse(x.toUTCString())
                      Date.parse(x.toISOString())

However, the expression

Date.parse(x.toLocaleString())

is not required to produce the same Number 值 as the preceding three expressions and, in general, the value produced by Date.parse is 实现-dependent when given any String 值 that does not conform to the Date Time String Format (20.3.1.15) and that could not be produced in that 实现 by the toString or toUTCString method.

20.3.3.3Date.prototype

The 初始值 of Date.prototype is the 内部对象 %DatePrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

20.3.3.4Date.UTC ( `year` [ , `month` [ , `date` [ , `hours` [ , `minutes` [ , `seconds` [ , `ms` ] ] ] ] ] ] )

When the UTC function is called, 执行如下:

Let y be ? ToNumber(year).
If month is present, let m be ? ToNumber(month); else let m be 0.
If date is present, let dt be ? ToNumber(date); else let dt be 1.
If hours is present, let h be ? ToNumber(hours); else let h be 0.
If minutes is present, let min be ? ToNumber(minutes); else let min be 0.
If seconds is present, let s be ? ToNumber(seconds); else let s be 0.
If ms is present, let milli be ? ToNumber(ms); else let milli be 0.
If y is not NaN and 0 ≤ ToInteger(y) ≤ 99, let yr be 1900+ToInteger(y); otherwise, let yr be y.
Return TimeClip(MakeDate(MakeDay(yr, m, dt), MakeTime(h, min, s, milli))).

The length property of the UTC function is 7.

Note

The UTC function differs from the Date 构造器 in two ways: it returns a time value as a Number, rather than creating a Date object, and it interprets the arguments in UTC rather than as local time.

20.3.4日期原型对象的属性

The Date 原型对象 is the 内部对象 %DatePrototype%. The Date 原型对象 is itself an 普通对象. It is not a Date instance and does not have a [[DateValue]] 内部属性.

[[Prototype]] 内部属性的值 of the Date 原型对象 is the 内部对象 %ObjectPrototype%.

Unless explicitly defined otherwise, the methods of the Date 原型对象 defined below are not generic and the this value passed to them must be an object that has a [[DateValue]] 内部属性 that has been initialized to a time value.

The 抽象操作 thisTimeValue(value) 执行如下:

If Type(value) is Object and value has a [[DateValue]] 内部属性, then
1. Return value.[[DateValue]].
抛出一个 TypeError 异常.

In following descriptions of functions that are 日期原型对象的属性, the phrase “this Date object” refers to the object that is the this value for the invocation of the function. If the Type of the this value is not Object, a TypeError 异常 is thrown. The phrase “this time value” within the specification of a method refers to the result returned by calling the 抽象操作 thisTimeValue with the this value of the method invocation passed as the argument.

20.3.4.1Date.prototype.constructor

The 初始值 of Date.prototype.constructor is the 内部对象 %Date%.

20.3.4.2Date.prototype.getDate ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return DateFromTime(LocalTime(t)).

20.3.4.3Date.prototype.getDay ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return WeekDay(LocalTime(t)).

20.3.4.4Date.prototype.getFullYear ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return YearFromTime(LocalTime(t)).

20.3.4.5Date.prototype.getHours ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return HourFromTime(LocalTime(t)).

20.3.4.6Date.prototype.getMilliseconds ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return msFromTime(LocalTime(t)).

20.3.4.7Date.prototype.getMinutes ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return MinFromTime(LocalTime(t)).

20.3.4.8Date.prototype.getMonth ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return MonthFromTime(LocalTime(t)).

20.3.4.9Date.prototype.getSeconds ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return SecFromTime(LocalTime(t)).

20.3.4.10Date.prototype.getTime ( )

The following steps are performed:

Return ? thisTimeValue(this value).

20.3.4.11Date.prototype.getTimezoneOffset ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return (t - LocalTime(t)) / msPerMinute.

20.3.4.12Date.prototype.getUTCDate ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return DateFromTime(t).

20.3.4.13Date.prototype.getUTCDay ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return WeekDay(t).

20.3.4.14Date.prototype.getUTCFullYear ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return YearFromTime(t).

20.3.4.15Date.prototype.getUTCHours ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return HourFromTime(t).

20.3.4.16Date.prototype.getUTCMilliseconds ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return msFromTime(t).

20.3.4.17Date.prototype.getUTCMinutes ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return MinFromTime(t).

20.3.4.18Date.prototype.getUTCMonth ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return MonthFromTime(t).

20.3.4.19Date.prototype.getUTCSeconds ( )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return SecFromTime(t).

20.3.4.20Date.prototype.setDate ( `date` )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t)).
Let u be TimeClip(UTC(newDate)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

20.3.4.21Date.prototype.setFullYear ( `year` [ , `month` [ , `date` ] ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, let t be +0; otherwise, let t be LocalTime(t).
Let y be ? ToNumber(year).
If month is not present, let m be MonthFromTime(t); otherwise, let m be ? ToNumber(month).
If date is not present, let dt be DateFromTime(t); otherwise, let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(y, m, dt), TimeWithinDay(t)).
Let u be TimeClip(UTC(newDate)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

The length property of the setFullYear method is 3.

Note

If month is not present, this method behaves as if month was present with the value getMonth(). If date is not present, it behaves as if date was present with the value getDate().

20.3.4.22Date.prototype.setHours ( `hour` [ , `min` [ , `sec` [ , `ms` ] ] ] )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let h be ? ToNumber(hour).
If min is not present, let m be MinFromTime(t); otherwise, let m be ? ToNumber(min).
If sec is not present, let s be SecFromTime(t); otherwise, let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t); otherwise, let milli be ? ToNumber(ms).
Let date be MakeDate(Day(t), MakeTime(h, m, s, milli)).
Let u be TimeClip(UTC(date)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

The length property of the setHours method is 4.

Note

If min is not present, this method behaves as if min was present with the value getMinutes(). If sec is not present, it behaves as if sec was present with the value getSeconds(). If ms is not present, it behaves as if ms was present with the value getMilliseconds().

20.3.4.23Date.prototype.setMilliseconds ( `ms` )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let ms be ? ToNumber(ms).
Let time be MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), ms).
Let u be TimeClip(UTC(MakeDate(Day(t), time))).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

20.3.4.24Date.prototype.setMinutes ( `min` [ , `sec` [ , `ms` ] ] )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let m be ? ToNumber(min).
If sec is not present, let s be SecFromTime(t); otherwise, let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t); otherwise, let milli be ? ToNumber(ms).
Let date be MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)).
Let u be TimeClip(UTC(date)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

The length property of the setMinutes method is 3.

Note

If sec is not present, this method behaves as if sec was present with the value getSeconds(). If ms is not present, this behaves as if ms was present with the value getMilliseconds().

20.3.4.25Date.prototype.setMonth ( `month` [ , `date` ] )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let m be ? ToNumber(month).
If date is not present, let dt be DateFromTime(t); otherwise, let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t)).
Let u be TimeClip(UTC(newDate)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

The length property of the setMonth method is 2.

Note

If date is not present, this method behaves as if date was present with the value getDate().

20.3.4.26Date.prototype.setSeconds ( `sec` [ , `ms` ] )

The following steps are performed:

Let t be LocalTime(? thisTimeValue(this value)).
Let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t); otherwise, let milli be ? ToNumber(ms).
Let date be MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)).
Let u be TimeClip(UTC(date)).
Set the [[DateValue]] 内部属性 of this Date object to u.
Return u.

The length property of the setSeconds method is 2.

Note

If ms is not present, this method behaves as if ms was present with the value getMilliseconds().

20.3.4.27Date.prototype.setTime ( `time` )

The following steps are performed:

Perform ? thisTimeValue(this value).
Let t be ? ToNumber(time).
Let v be TimeClip(t).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

20.3.4.28Date.prototype.setUTCDate ( `date` )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(YearFromTime(t), MonthFromTime(t), dt), TimeWithinDay(t)).
Let v be TimeClip(newDate).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

20.3.4.29Date.prototype.setUTCFullYear ( `year` [ , `month` [ , `date` ] ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
If t is NaN, let t be +0.
Let y be ? ToNumber(year).
If month is not present, let m be MonthFromTime(t); otherwise, let m be ? ToNumber(month).
If date is not present, let dt be DateFromTime(t); otherwise, let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(y, m, dt), TimeWithinDay(t)).
Let v be TimeClip(newDate).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

The length property of the setUTCFullYear method is 3.

Note

If month is not present, this method behaves as if month was present with the value getUTCMonth(). If date is not present, it behaves as if date was present with the value getUTCDate().

20.3.4.30Date.prototype.setUTCHours ( `hour` [ , `min` [ , `sec` [ , `ms` ] ] ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let h be ? ToNumber(hour).
If min is not present, let m be MinFromTime(t); otherwise, let m be ? ToNumber(min).
If sec is not present, let s be SecFromTime(t); otherwise, let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t); otherwise, let milli be ? ToNumber(ms).
Let newDate be MakeDate(Day(t), MakeTime(h, m, s, milli)).
Let v be TimeClip(newDate).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

The length property of the setUTCHours method is 4.

Note

If min is not present, this method behaves as if min was present with the value getUTCMinutes(). If sec is not present, it behaves as if sec was present with the value getUTCSeconds(). If ms is not present, it behaves as if ms was present with the value getUTCMilliseconds().

20.3.4.31Date.prototype.setUTCMilliseconds ( `ms` )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let milli be ? ToNumber(ms).
Let time be MakeTime(HourFromTime(t), MinFromTime(t), SecFromTime(t), milli).
Let v be TimeClip(MakeDate(Day(t), time)).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

20.3.4.32Date.prototype.setUTCMinutes ( `min` [ , `sec` [ , `ms` ] ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let m be ? ToNumber(min).
If sec is not present, let s be SecFromTime(t).
Else,
1. Let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t).
Else,
1. Let milli be ? ToNumber(ms).
Let date be MakeDate(Day(t), MakeTime(HourFromTime(t), m, s, milli)).
Let v be TimeClip(date).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

The length property of the setUTCMinutes method is 3.

Note

If sec is not present, this method behaves as if sec was present with the value getUTCSeconds(). If ms is not present, it function behaves as if ms was present with the value return by getUTCMilliseconds().

20.3.4.33Date.prototype.setUTCMonth ( `month` [ , `date` ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let m be ? ToNumber(month).
If date is not present, let dt be DateFromTime(t).
Else,
1. Let dt be ? ToNumber(date).
Let newDate be MakeDate(MakeDay(YearFromTime(t), m, dt), TimeWithinDay(t)).
Let v be TimeClip(newDate).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

The length property of the setUTCMonth method is 2.

Note

If date is not present, this method behaves as if date was present with the value getUTCDate().

20.3.4.34Date.prototype.setUTCSeconds ( `sec` [ , `ms` ] )

The following steps are performed:

Let t be ? thisTimeValue(this value).
Let s be ? ToNumber(sec).
If ms is not present, let milli be msFromTime(t).
Else,
1. Let milli be ? ToNumber(ms).
Let date be MakeDate(Day(t), MakeTime(HourFromTime(t), MinFromTime(t), s, milli)).
Let v be TimeClip(date).
Set the [[DateValue]] 内部属性 of this Date object to v.
Return v.

The length property of the setUTCSeconds method is 2.

Note

If ms is not present, this method behaves as if ms was present with the value getUTCMilliseconds().

20.3.4.35Date.prototype.toDateString ( )

The following steps are performed:

Let O be this Date object.
Let tv be ? thisTimeValue(O).
If tv is NaN, return "Invalid Date".
Let t be LocalTime(tv).
Return DateString(t).

20.3.4.36Date.prototype.toISOString ( )

This function returns a String 值 representing the instance in time corresponding to this time value. The format of the String is the Date Time string format defined in 20.3.1.15. All fields are present in the String. The time zone is always UTC, denoted by the suffix Z. If this time value is not a finite Number or if the year is not a value that can be represented in that format (if necessary using extended year format), a RangeError 异常 is thrown.

20.3.4.37Date.prototype.toJSON ( `key` )

This function provides a String representation of a Date object for use by JSON.stringify (24.5.2).

When the toJSON method is called with argument key, 执行如下:

Let O be ? ToObject(this value).
Let tv be ? ToPrimitive(O, hint Number).
If Type(tv) is Number and tv is not finite, return null.
Return ? Invoke(O, "toISOString").

Note 1

The argument is ignored.

Note 2

The toJSON function 是故意通用的; 不需要 its this value be a Date object. Therefore, 它可以转换为其它对象类型的方法而被使用. However, it does require that any such object have a toISOString method.

20.3.4.38Date.prototype.toLocaleDateString ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the Date.prototype.toLocaleDateString method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleDateString method is used.

This function returns a String 值. The contents of the String are 实现-dependent, but are intended to represent the “date” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

The meaning of the optional parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not use those parameter positions for anything else.

20.3.4.39Date.prototype.toLocaleString ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the Date.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleString method is used.

This function returns a String 值. The contents of the String are 实现-dependent, but are intended to represent the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

20.3.4.40Date.prototype.toLocaleTimeString ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the Date.prototype.toLocaleTimeString method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleTimeString method is used.

This function returns a String 值. The contents of the String are 实现-dependent, but are intended to represent the “time” portion of the Date in the current time zone in a convenient, human-readable form that corresponds to the conventions of the host environment's current locale.

20.3.4.41Date.prototype.toString ( )

The following steps are performed:

Let tv be ? thisTimeValue(this value).
Return ToDateString(tv).

Note 1

For any Date object d whose milliseconds amount is zero, the result of Date.parse(d.toString()) is equal to d.valueOf(). See 20.3.3.2.

Note 2

The toString function 是故意通用的; 不需要 its this value be a Date object. Therefore, 它可以转换为其它对象类型的方法而被使用.

20.3.4.41.1运行时语义: TimeString( `tv` )

The following steps are performed:

Assert: Type(tv) is Number.
Assert: tv is not NaN.
Let hour be the String representation of HourFromTime(tv), formatted as a two-digit number, padded to the left with a zero if necessary.
Let minute be the String representation of MinFromTime(tv), formatted as a two-digit number, padded to the left with a zero if necessary.
Let second be the String representation of SecFromTime(tv), formatted as a two-digit number, padded to the left with a zero if necessary.
Return the string-concatenation of hour, ":", minute, ":", second, the 代码单元 0x0020 (SPACE), and "GMT".

20.3.4.41.2运行时语义: DateString( `tv` )

The following steps are performed:

Assert: Type(tv) is Number.
Assert: tv is not NaN.
Let weekday be the Name of the entry in Table 46 with the Number WeekDay(tv).
Let month be the Name of the entry in Table 47 with the Number MonthFromTime(tv).
Let day be the String representation of DateFromTime(tv), formatted as a two-digit number, padded to the left with a zero if necessary.
Let year be the String representation of YearFromTime(tv), formatted as a number of at least four digits, padded to the left with zeroes if necessary.
Return the string-concatenation of weekday, the 代码单元 0x0020 (SPACE), month, the 代码单元 0x0020 (SPACE), day, the 代码单元 0x0020 (SPACE), and year.

Table 46: Names of days of the week

Number	Name
0	`"Sun"`
1	`"Mon"`
2	`"Tue"`
3	`"Wed"`
4	`"Thu"`
5	`"Fri"`
6	`"Sat"`

Table 47: Names of months of the year

Number	Name
0	`"Jan"`
1	`"Feb"`
2	`"Mar"`
3	`"Apr"`
4	`"May"`
5	`"Jun"`
6	`"Jul"`
7	`"Aug"`
8	`"Sep"`
9	`"Oct"`
10	`"Nov"`
11	`"Dec"`

20.3.4.41.3运行时语义: TimeZoneString( `tv` )

The following steps are performed:

Assert: Type(tv) is Number.
Assert: tv is not NaN.
Let offset be LocalTZA(tv, true).
If offset ≥ 0, let offsetSign be "+"; otherwise, let offsetSign be "-".
Let offsetMin be the String representation of MinFromTime(abs(offset)), formatted as a two-digit number, padded to the left with a zero if necessary.
Let offsetHour be the String representation of HourFromTime(abs(offset)), formatted as a two-digit number, padded to the left with a zero if necessary.
Let tzName be an 实现-defined string that is either the empty string or the string-concatenation of the 代码单元 0x0020 (SPACE), the 代码单元 0x0028 (LEFT PARENTHESIS), an 实现-dependent timezone name, and the 代码单元 0x0029 (RIGHT PARENTHESIS).
Return the string-concatenation of offsetSign, offsetHour, offsetMin, and tzName.

20.3.4.41.4运行时语义: ToDateString( `tv` )

The following steps are performed:

Assert: Type(tv) is Number.
If tv is NaN, return "Invalid Date".
Let t be LocalTime(tv).
Return the string-concatenation of DateString(t), the 代码单元 0x0020 (SPACE), TimeString(t), and TimeZoneString(tv).

20.3.4.42Date.prototype.toTimeString ( )

The following steps are performed:

Let O be this Date object.
Let tv be ? thisTimeValue(O).
If tv is NaN, return "Invalid Date".
Let t be LocalTime(tv).
Return the string-concatenation of TimeString(t) and TimeZoneString(tv).

20.3.4.43Date.prototype.toUTCString ( )

The following steps are performed:

Let O be this Date object.
Let tv be ? thisTimeValue(O).
If tv is NaN, return "Invalid Date".
Let weekday be the Name of the entry in Table 46 with the Number WeekDay(tv).
Let month be the Name of the entry in Table 47 with the Number MonthFromTime(tv).
Let day be the String representation of DateFromTime(tv), formatted as a two-digit number, padded to the left with a zero if necessary.
Let year be the String representation of YearFromTime(tv), formatted as a number of at least four digits, padded to the left with zeroes if necessary.
Return the string-concatenation of weekday, ",", the 代码单元 0x0020 (SPACE), day, the 代码单元 0x0020 (SPACE), month, the 代码单元 0x0020 (SPACE), year, the 代码单元 0x0020 (SPACE), and TimeString(tv).

20.3.4.44Date.prototype.valueOf ( )

The following steps are performed:

Return ? thisTimeValue(this value).

20.3.4.45Date.prototype [ @@toPrimitive ] ( `hint` )

This function is called by ES language operators to convert a Date object to a 原始值. The allowed values for hint are "default", "number", and "string". 日期对象, are unique among 内置 ES object in that they treat "default" as being equivalent to "string", All other 内置 ES 对象 treat "default" as being equivalent to "number".

When the @@toPrimitive method is called with argument hint, 执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If hint is the String 值 "string" or the String 值 "default", then
1. Let tryFirst be "string".
Else if hint is the String 值 "number", then
1. Let tryFirst be "number".
Else, 抛出一个 TypeError 异常.
Return ? OrdinaryToPrimitive(O, tryFirst).

The value of the name property of this function is "[Symbol.toPrimitive]".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

20.3.5日期实例的属性

Date 实例是从 Date 原型对象上继承属性的普通对象。Date 实例也有 [[DateValue]] 内部属性。[[DateValue]] 内部属性是由 this Date 对象表示的时间值。

21文本处理

21.1字符串对象

21.1.1String 构造器

The String 构造器 is the %String% 内部对象 and the 初始值 of the String property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 String 对象. When String 被作为一个函数调用而不是一个构造器, 它会执行一个类型转换.

The String 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 String behaviour must include a super call to the String 构造器以便创建和初始化子类实例 with a [[StringData]] 内部属性.

21.1.1.1String ( `value` )

When String is called with argument value, 执行如下:

如果没有参数被传递给该函数调用, let s be "".
Else,
1. If NewTarget is undefined and Type(value) is Symbol, return SymbolDescriptiveString(value).
2. Let s be ? ToString(value).
If NewTarget is undefined, return s.
Return ? StringCreate(s, ? GetPrototypeFromConstructor(NewTarget, "%StringPrototype%")).

21.1.2String 构造器的属性

[[Prototype]] 内部属性的值 of the String 构造器 is the 内部对象 %FunctionPrototype%.

The String 构造器有以下属性:

21.1.2.1String.fromCharCode ( ...`codeUnits` )

The String.fromCharCode 函数可以以任何数量的参数（形成剩余参数）的形式被调用 codeUnits. 执行如下:

Let codeUnits be a List 包含了传递给该函数的参数.
Let length be the number of elements in codeUnits.
Let elements be a new empty List.
Let nextIndex be 0.
Repeat, while nextIndex < length
1. Let next be codeUnits[nextIndex].
2. Let nextCU be ? ToUint16(next).
3. Append nextCU to the end of elements.
4. Let nextIndex be nextIndex + 1.
Return the String 值 whose elements are, in order, the elements in the List elements. If length is 0, the empty string is returned.

The length property of the fromCharCode function is 1.

21.1.2.2String.fromCodePoint ( ...`codePoints` )

The String.fromCodePoint 函数可以以任何数量的参数（形成剩余参数）的形式被调用 codePoints. 执行如下:

Let codePoints be a List 包含了传递给该函数的参数.
Let length be the number of elements in codePoints.
Let elements be a new empty List.
Let nextIndex be 0.
Repeat, while nextIndex < length
1. Let next be codePoints[nextIndex].
2. Let nextCP be ? ToNumber(next).
3. If SameValue(nextCP, ToInteger(nextCP)) is false, 抛出一个 RangeError 异常.
4. If nextCP < 0 or nextCP > 0x10FFFF, 抛出一个 RangeError 异常.
5. Append the elements of the UTF16Encoding of nextCP to the end of elements.
6. Let nextIndex be nextIndex + 1.
Return the String 值 whose elements are, in order, the elements in the List elements. If length is 0, the empty string is returned.

The length property of the fromCodePoint function is 1.

21.1.2.3String.prototype

The 初始值 of String.prototype is the 内部对象 %StringPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

21.1.2.4String.raw ( `template`, ...`substitutions` )

The String.raw 函数可以以可变数量的参数的形式被调用. The first argument is template and the remainder of the arguments form the List substitutions. 执行如下:

Let substitutions be a List consisting of all of the arguments passed to this function, starting with the second argument. If fewer than two arguments were passed, the List is empty.
Let numberOfSubstitutions be the number of elements in substitutions.
Let cooked be ? ToObject(template).
Let raw be ? ToObject(? Get(cooked, "raw")).
Let literalSegments be ? ToLength(? Get(raw, "length")).
If literalSegments ≤ 0, return the empty string.
Let stringElements be a new empty List.
Let nextIndex be 0.
Repeat,
1. Let nextKey be ! ToString(nextIndex).
2. Let nextSeg be ? ToString(? Get(raw, nextKey)).
3. Append in order the 代码单元 elements of nextSeg to the end of stringElements.
4. If nextIndex + 1 = literalSegments, then
  1. Return the String 值 whose 代码单元 are, in order, the elements in the List stringElements. If stringElements has no elements, the empty string is returned.
5. If nextIndex < numberOfSubstitutions, let next be substitutions[nextIndex].
6. Else, let next be the empty String.
7. Let nextSub be ? ToString(next).
8. Append in order the 代码单元 elements of nextSub to the end of stringElements.
9. Let nextIndex be nextIndex + 1.

Note

String.raw is intended for use as a tag function of a Tagged Template (12.3.7). When called as such, the first argument will be a well formed template object and the rest parameter will contain the substitution values.

21.1.3String 原型对象的属性

The String 原型对象 is the 内部对象 %StringPrototype%. The String 原型对象 is a String 外来对象 and has the 内部方法 specified for such objects. It has a [[StringData]] 内部属性 with the value "". It has a length property whose 初始值 is 0 and whose 特性 are { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

[[Prototype]] 内部属性的值 of the String 原型对象 is the 内部对象 %ObjectPrototype%.

除非显式说明, the methods of the String 原型对象 defined below are not generic and the this value passed to them 必须是一个字符值或一个对象 that has a [[StringData]] 内部属性 that 已经被初始化为一个字符值.

The 抽象操作 thisStringValue(value) 执行如下:

If Type(value) is String, return value.
If Type(value) is Object and value has a [[StringData]] 内部属性, then
1. Assert: value.[[StringData]] is a String 值.
2. Return value.[[StringData]].
抛出一个 TypeError 异常.

21.1.3.1String.prototype.charAt ( `pos` )

Note 1

返回一个单一元素字符串 containing the 代码单元 at index pos within the String 值 resulting from converting this object to a String. 如果该索引处没有元素, 那么结果是一个空字符串. 结果是一个 String 值, 而不是一个 String 对象.

If pos 是一个 Number 类型的整数值, then the result of x.charAt(pos) is equal to the result of x.substring(pos, pos+1).

When the charAt method is called with one argument pos, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let position be ? ToInteger(pos).
Let size be the length of S.
If position < 0 or position ≥ size, return the empty String.
Return the String 值 of length 1, containing one 代码单元 from S, namely the 代码单元 at index position.

Note 2

The charAt function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.2String.prototype.charCodeAt ( `pos` )

Note 1

Returns a Number (一个非负整数 less than 2¹⁶) that is the 数字值 of the 代码单元 at index pos within the String resulting from converting this object to a String. 如果该索引处没有元素, the result is NaN.

When the charCodeAt method is called with one argument pos, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let position be ? ToInteger(pos).
Let size be the length of S.
If position < 0 or position ≥ size, return NaN.
Return a value of Number 类型, whose value is the 数字值 of the 代码单元 at index position within the String S.

Note 2

The charCodeAt function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

21.1.3.3String.prototype.codePointAt ( `pos` )

Note 1

Returns 一个非负整数 Number less than 0x110000 that 是 UTF-16 编码码点的码点值 (6.1.4) starting at the string element at index pos within the String resulting from converting this object to a String. 如果该索引处没有元素, the result is undefined. 如果一个有效的 UTF-16 代理对没有 begin at pos, the result is the 代码单元 at pos.

When the codePointAt method is called with one argument pos, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let position be ? ToInteger(pos).
Let size be the length of S.
If position < 0 or position ≥ size, return undefined.
Let first be the 数字值 of the 代码单元 at index position within the String S.
If first < 0xD800 or first > 0xDBFF or position+1 = size, return first.
Let second be the 数字值 of the 代码单元 at index position+1 within the String S.
If second < 0xDC00 or second > 0xDFFF, return first.
Return UTF16Decode(first, second).

Note 2

The codePointAt function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

21.1.3.4String.prototype.concat ( ...`args` )

Note 1

When the concat 方法被调用，它会返回字符串值 consisting of the 代码单元 of the this 对象（转换为一个字符串），后面跟随着每一个参数（被转换为一个字符串）的代码单元. 结果是一个 String 值, 而不是一个 String 对象.

When the concat 方法以零个或多个参数的形式被调用, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let args be a List whose elements are the arguments passed to this function.
Let R be S.
Repeat, while args is not empty
1. Remove the first element from args and let next be the value of that element.
2. Let nextString be ? ToString(next).
3. Set R to the string-concatenation of the previous value of R and nextString.
Return R.

The length property of the concat method is 1.

Note 2

The concat function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

21.1.3.5String.prototype.constructor

The 初始值 of String.prototype.constructor is the 内部对象 %String%.

21.1.3.6String.prototype.endsWith ( `searchString` [ , `endPosition` ] )

执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let isRegExp be ? IsRegExp(searchString).
If isRegExp is true, 抛出一个 TypeError 异常.
Let searchStr be ? ToString(searchString).
Let len be the length of S.
If endPosition is undefined, let pos be len, else let pos be ? ToInteger(endPosition).
Let end be min(max(pos, 0), len).
Let searchLength be the length of searchStr.
Let start be end - searchLength.
If start is less than 0, return false.
If the sequence of elements of S starting at start of length searchLength is the same as the full element sequence of searchStr, return true.
Otherwise, return false.

Note 1

Returns true if the sequence of elements of searchString converted to a String is the same as the corresponding elements of this object (converted to a String) starting at endPosition - length(this). Otherwise returns false.

Note 2

Throwing an 异常 if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.

Note 3

The endsWith function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.7String.prototype.includes ( `searchString` [ , `position` ] )

The includes method takes two arguments, searchString and position, and 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let isRegExp be ? IsRegExp(searchString).
If isRegExp is true, 抛出一个 TypeError 异常.
Let searchStr be ? ToString(searchString).
Let pos be ? ToInteger(position). (If position is undefined, this step produces the value 0.)
Let len be the length of S.
Let start be min(max(pos, 0), len).
Let searchLen be the length of searchStr.
If there exists any integer k not smaller than start such that k + searchLen is not greater than len, and for all nonnegative integers j less than searchLen, the 代码单元 at index k+j within S is the same as the 代码单元 at index j within searchStr, return true; but if there is no such integer k, return false.

Note 1

If searchString appears as a substring of the result of converting this object to a String, at one or more indices that are greater than or equal to position, return true; otherwise, returns false. If position is undefined, 0 is assumed, so as to search all of the String.

Note 2

Throwing an 异常 if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.

Note 3

The includes function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.8String.prototype.indexOf ( `searchString` [ , `position` ] )

Note 1

If searchString appears as a substring of the result of converting this object to a String, at one or more indices that are greater than or equal to position, then the smallest such index is returned; otherwise, -1 is returned. If position is undefined, 0 is assumed, so as to search all of the String.

The indexOf method takes two arguments, searchString and position, and 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let searchStr be ? ToString(searchString).
Let pos be ? ToInteger(position). (If position is undefined, this step produces the value 0.)
Let len be the length of S.
Let start be min(max(pos, 0), len).
Let searchLen be the length of searchStr.
Return the smallest possible integer k not smaller than start such that k+searchLen is not greater than len, and for all nonnegative integers j less than searchLen, the 代码单元 at index k+j within S is the same as the 代码单元 at index j within searchStr; but if there is no such integer k, return the value -1.

Note 2

The indexOf function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.9String.prototype.lastIndexOf ( `searchString` [ , `position` ] )

Note 1

If searchString appears as a substring of the result of converting this object to a String at one or more indices that are smaller than or equal to position, then the greatest such index is returned; otherwise, -1 is returned. If position is undefined, the length of the String 值 is assumed, so as to search all of the String.

The lastIndexOf method takes two arguments, searchString and position, and 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let searchStr be ? ToString(searchString).
Let numPos be ? ToNumber(position). (If position is undefined, this step produces the value NaN.)
If numPos is NaN, let pos be +∞; otherwise, let pos be ToInteger(numPos).
Let len be the length of S.
Let start be min(max(pos, 0), len).
Let searchLen be the length of searchStr.
Return the largest possible nonnegative integer k not larger than start such that k+searchLen is not greater than len, and for all nonnegative integers j less than searchLen, the 代码单元 at index k+j within S is the same as the 代码单元 at index j within searchStr; but if there is no such integer k, return the value -1.

Note 2

The lastIndexOf function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.10String.prototype.localeCompare ( `that` [ , `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the localeCompare method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the localeCompare method is used.

When the localeCompare method is called with argument that, it returns a Number other than NaN that represents the result of a locale-sensitive String comparison of the this value (converted to a String) with that (converted to a String). The two Strings are S and That. The two Strings are compared in an 实现-defined fashion. The result is intended to order String values in the sort order specified by a host default locale, and will be negative, zero, or positive, depending on whether S comes before That in the sort order, the Strings are equal, or S comes after That in the sort order, respectively.

Before performing the comparisons, the following steps are performed to prepare the Strings:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let That be ? ToString(that).

The meaning of the optional second and third parameters to this method are defined in the ECMA-402 specification; implementations that do not include ECMA-402 support must not assign any other interpretation to those parameter positions.

The localeCompare method, if considered as a function of two arguments this and that, is a consistent comparison function (as defined in 22.1.3.25) on the set of all Strings.

The actual return values are 实现-defined to permit implementers to encode additional information in the value, but the function is required to define a total ordering on all Strings. This function must treat Strings that are canonically equivalent according to the Unicode standard as identical and must return 0 when comparing Strings that are considered canonically equivalent.

Note 1

The localeCompare method itself is not directly suitable as an argument to Array.prototype.sort because the latter requires a function of two arguments.

Note 2

This function is intended to rely on whatever language-sensitive comparison functionality is available to the ES environment from the host environment, and to compare according to the rules of the host environment's current locale. However, regardless of the host provided comparison capabilities, this function must treat Strings that are canonically equivalent according to the Unicode standard as identical. It is recommended that this function should not honour Unicode compatibility equivalences or decompositions. For a definition and discussion of canonical equivalence see the Unicode Standard, chapters 2 and 3, as well as Unicode Standard Annex #15, Unicode Normalization Forms (https://unicode.org/reports/tr15/) and Unicode Technical Note #5, Canonical Equivalence in Applications (https://www.unicode.org/notes/tn5/). Also see Unicode Technical Standard #10, Unicode Collation 算法 (https://unicode.org/reports/tr10/).

Note 3

The localeCompare function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.11String.prototype.match ( `regexp` )

When the match method is called with argument regexp, 执行如下:

Let O be ? RequireObjectCoercible(this value).
If regexp is neither undefined nor null, then
1. Let matcher be ? GetMethod(regexp, @@match).
2. If matcher is not undefined, then
  1. Return ? Call(matcher, regexp, « O »).
Let S be ? ToString(O).
Let rx be ? RegExpCreate(regexp, undefined).
Return ? Invoke(rx, @@match, « S »).

Note

The match function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.12String.prototype.normalize ( [ `form` ] )

When the normalize method is called with one argument form, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
If form is not present or form is undefined, let form be "NFC".
Let f be ? ToString(form).
If f is not one of "NFC", "NFD", "NFKC", or "NFKD", 抛出一个 RangeError 异常.
Let ns be the String 值 that is the result of normalizing S into the normalization form named by f as specified in https://unicode.org/reports/tr15/.
Return ns.

Note

The normalize function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

21.1.3.13String.prototype.padEnd( `maxLength` [ , `fillString` ] )

When the padEnd method is called, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let intMaxLength be ? ToLength(maxLength).
Let stringLength be the length of S.
If intMaxLength is not greater than stringLength, return S.
If fillString is undefined, let filler be the String 值 consisting solely of the 代码单元 0x0020 (SPACE).
Else, let filler be ? ToString(fillString).
If filler is the empty String, return S.
Let fillLen be intMaxLength - stringLength.
Let truncatedStringFiller be the String 值 consisting of repeated concatenations of filler truncated to length fillLen.
Return the string-concatenation of S and truncatedStringFiller.

Note 1

The first argument maxLength will be clamped such that it can be no smaller than the length of the this value.

Note 2

The optional second argument fillString defaults to " " (the String 值 consisting of the 代码单元 0x0020 SPACE).

21.1.3.14String.prototype.padStart( `maxLength` [ , `fillString` ] )

When the padStart method is called, 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let intMaxLength be ? ToLength(maxLength).
Let stringLength be the length of S.
If intMaxLength is not greater than stringLength, return S.
If fillString is undefined, let filler be the String 值 consisting solely of the 代码单元 0x0020 (SPACE).
Else, let filler be ? ToString(fillString).
If filler is the empty String, return S.
Let fillLen be intMaxLength - stringLength.
Let truncatedStringFiller be the String 值 consisting of repeated concatenations of filler truncated to length fillLen.
Return the string-concatenation of truncatedStringFiller and S.

Note 1

The first argument maxLength will be clamped such that it can be no smaller than the length of the this value.

Note 2

The optional second argument fillString defaults to " " (the String 值 consisting of the 代码单元 0x0020 SPACE).

21.1.3.15String.prototype.repeat ( `count` )

执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let n be ? ToInteger(count).
If n < 0, 抛出一个 RangeError 异常.
If n is +∞, 抛出一个 RangeError 异常.
Let T be the String 值 that is made from n copies of S appended together. If n is 0, T is the empty String.
Return T.

Note 1

This method creates the String 值 consisting of the 代码单元 of the this object (converted to String) repeated count times.

Note 2

The repeat function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.16String.prototype.replace ( `searchValue`, `replaceValue` )

When the replace method is called with arguments searchValue and replaceValue, 执行如下:

Let O be ? RequireObjectCoercible(this value).
If searchValue is neither undefined nor null, then
1. Let replacer be ? GetMethod(searchValue, @@replace).
2. If replacer is not undefined, then
  1. Return ? Call(replacer, searchValue, « O, replaceValue »).
Let string be ? ToString(O).
Let searchString be ? ToString(searchValue).
Let functionalReplace be IsCallable(replaceValue).
If functionalReplace is false, then
1. Let replaceValue be ? ToString(replaceValue).
Search string for the first occurrence of searchString and let pos be the index within string of the first 代码单元 of the matched substring and let matched be searchString. If no occurrences of searchString were found, return string.
If functionalReplace is true, then
1. Let replValue be ? Call(replaceValue, undefined, « matched, pos, string »).
2. Let replStr be ? ToString(replValue).
Else,
1. Let captures be a new empty List.
2. Let replStr be GetSubstitution(matched, string, pos, captures, undefined, replaceValue).
Let tailPos be pos + the number of 代码单元 in matched.
Let newString be the string-concatenation of the first pos 代码单元 of string, replStr, and the trailing substring of string starting at index tailPos. If pos is 0, the first element of the concatenation will be the empty String.
Return newString.

Note

The replace function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.16.1运行时语义: GetSubstitution( `matched`, `str`, `position`, `captures`, `namedCaptures`, `replacement` )

The 抽象操作 GetSubstitution 执行如下:

Assert: Type(matched) is String.
Let matchLength be the number of 代码单元 in matched.
Assert: Type(str) is String.
Let stringLength be the number of 代码单元 in str.
Assert: position is 一个非负整数.
Assert: position ≤ stringLength.
Assert: captures is a possibly empty List of Strings.
Assert: Type(replacement) is String.
Let tailPos be position + matchLength.
Let m be the number of elements in captures.
If namedCaptures is not undefined, then
1. Set namedCaptures to ? ToObject(namedCaptures).
Let result be the String 值 derived from replacement by copying 代码单元 elements from replacement to result while performing replacements as specified in Table 48. These $ replacements are done left-to-right, and, once such a replacement is performed, the new replacement text is not subject to further replacements.
Return result.

Table 48: Replacement Text Symbol Substitutions

代码单元	Unicode Characters	Replacement text
0x0024, 0x0024	`$$`	`$`
0x0024, 0x0026	`$&`	`matched`
0x0024, 0x0060	$`	If `position` is 0, the replacement is the empty String. Otherwise the replacement is the substring of `str` that starts at index 0 and whose last 代码单元 is at index `position` - 1.
0x0024, 0x0027	`$'`	If `tailPos` ≥ `stringLength`, the replacement is the empty String. Otherwise the replacement is the substring of `str` that starts at index `tailPos` and continues to the end of `str`.
0x0024, N Where 0x0031 ≤ N ≤ 0x0039	`$n` where `n` is one of `1 2 3 4 5 6 7 8 9` and `$n` is not followed by a decimal digit	The `n`^th element of `captures`, where `n` is a single digit in the range 1 to 9. If `n`≤`m` and the `n`^th element of `captures` is undefined, use the empty String instead. If `n`>`m`, no replacement is done.
0x0024, N, N Where 0x0030 ≤ N ≤ 0x0039	`$nn` where `n` is one of `0 1 2 3 4 5 6 7 8 9`	The `nn`^th element of `captures`, where `nn` is a two-digit decimal number in the range 01 to 99. If `nn`≤`m` and the `nn`^th element of `captures` is undefined, use the empty String instead. If `nn` is 00 or `nn`>`m`, no replacement is done.
0x0024, 0x003C	`$<`	If `namedCaptures` is undefined, the replacement text is the String `"$<"`. Else, Scan until the next `>` U+003E (GREATER-THAN SIGN). If none is found, the replacement text is the String `"$<"`. Else, Let `groupName` be the enclosed substring. Let `capture` be ? Get(`namedCaptures`, `groupName`). If `capture` is undefined, replace the text through `>` with the empty string. Otherwise, replace the text through `>` with ? ToString(`capture`).
0x0024	`$` in any context that does not match any of the above.	`$`

21.1.3.17String.prototype.search ( `regexp` )

When the search method is called with argument regexp, 执行如下:

Let O be ? RequireObjectCoercible(this value).
If regexp is neither undefined nor null, then
1. Let searcher be ? GetMethod(regexp, @@search).
2. If searcher is not undefined, then
  1. Return ? Call(searcher, regexp, « O »).
Let string be ? ToString(O).
Let rx be ? RegExpCreate(regexp, undefined).
Return ? Invoke(rx, @@search, « string »).

Note

The search function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.18String.prototype.slice ( `start`, `end` )

The slice method takes two arguments, start and end, and returns a substring of the result of converting this object to a String, starting from index start and running to, but not including, index end (or through the end of the String if end is undefined). If start is negative, it is treated as sourceLength+start where sourceLength is the length of the String. If end is negative, it is treated as sourceLength+end where sourceLength is the length of the String. 结果是一个 String 值, 而不是一个 String 对象. 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let len be the length of S.
Let intStart be ? ToInteger(start).
If end is undefined, let intEnd be len; else let intEnd be ? ToInteger(end).
If intStart < 0, let from be max(len + intStart, 0); otherwise let from be min(intStart, len).
If intEnd < 0, let to be max(len + intEnd, 0); otherwise let to be min(intEnd, len).
Let span be max(to - from, 0).
Return the String 值 containing span consecutive elements from S beginning with the element at index from.

Note

The slice function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

21.1.3.19String.prototype.split ( `separator`, `limit` )

Returns an Array object into which substrings of the result of converting this object to a String have been stored. The substrings are determined by searching from left to right for occurrences of separator; these occurrences are not part of any substring in the returned array, but serve to divide up the String 值. The value of separator may be a String of any length or it may be an object, 例如 a RegExp, that has a @@split method.

When the split method is called, 执行如下:

Let O be ? RequireObjectCoercible(this value).
If separator is neither undefined nor null, then
1. Let splitter be ? GetMethod(separator, @@split).
2. If splitter is not undefined, then
  1. Return ? Call(splitter, separator, « O, limit »).
Let S be ? ToString(O).
Let A be ! ArrayCreate(0).
Let lengthA be 0.
If limit is undefined, let lim be 2³²-1; else let lim be ? ToUint32(limit).
Let s be the length of S.
Let p be 0.
Let R be ? ToString(separator).
If lim = 0, return A.
If separator is undefined, then
1. Perform ! CreateDataProperty(A, "0", S).
2. Return A.
If s = 0, then
1. Let z be SplitMatch(S, 0, R).
2. If z is not false, return A.
3. Perform ! CreateDataProperty(A, "0", S).
4. Return A.
Let q be p.
Repeat, while q ≠ s
1. Let e be SplitMatch(S, q, R).
2. If e is false, let q be q+1.
3. Else e is an 整数索引 ≤ s,
  1. If e = p, let q be q+1.
  2. Else e ≠ p,
    1. Let T be the String 值 equal to the substring of S consisting of the 代码单元 at indices p (inclusive) through q (exclusive).
    2. Perform ! CreateDataProperty(A, ! ToString(lengthA), T).
    3. Increment lengthA by 1.
    4. If lengthA = lim, return A.
    5. Let p be e.
    6. Let q be p.
Let T be the String 值 equal to the substring of S consisting of the 代码单元 at indices p (inclusive) through s (exclusive).
Perform ! CreateDataProperty(A, ! ToString(lengthA), T).
Return A.

Note 1

The value of separator may be an empty String. In this case, separator does not match the empty substring at the beginning or end of the input String, nor does it match the empty substring at the end of the previous separator match. If separator is the empty String, the String is split up into individual 代码单元 elements; the length of the result array equals the length of the String, and each substring contains one 代码单元.

If the this object is (or converts to) the empty String, the result depends on whether separator can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.

If separator is undefined, then the result array contains just one String, which is the this value (converted to a String). If limit is not undefined, then the output array is truncated so that it contains no more than limit elements.

Note 2

The split function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.19.1运行时语义: SplitMatch ( `S`, `q`, `R` )

The 抽象操作 SplitMatch takes three parameters, a String S, an integer q, and a String R, and 执行如下 in order to return either false or the end index of a match:

Assert: Type(R) is String.
Let r be the number of 代码单元 in R.
Let s be the number of 代码单元 in S.
If q+r > s, return false.
If there exists an integer i between 0 (inclusive) and r (exclusive) such that the 代码单元 at index q+i within S is different from the 代码单元 at index i within R, return false.
Return q+r.

21.1.3.20String.prototype.startsWith ( `searchString` [ , `position` ] )

执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let isRegExp be ? IsRegExp(searchString).
If isRegExp is true, 抛出一个 TypeError 异常.
Let searchStr be ? ToString(searchString).
Let pos be ? ToInteger(position). (If position is undefined, this step produces the value 0.)
Let len be the length of S.
Let start be min(max(pos, 0), len).
Let searchLength be the length of searchStr.
If searchLength+start is greater than len, return false.
If the sequence of elements of S starting at start of length searchLength is the same as the full element sequence of searchStr, return true.
Otherwise, return false.

Note 1

This method returns true if the sequence of elements of searchString converted to a String is the same as the corresponding elements of this object (converted to a String) starting at index position. Otherwise returns false.

Note 2

Throwing an 异常 if the first argument is a RegExp is specified in order to allow future editions to define extensions that allow such argument values.

Note 3

The startsWith function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.21String.prototype.substring ( `start`, `end` )

The substring method takes two arguments, start and end, and returns a substring of the result of converting this object to a String, starting from index start and running to, but not including, index end of the String (or through the end of the String if end is undefined). 结果是一个 String 值, 而不是一个 String 对象.

If either argument is NaN or negative, it is replaced with zero; if either argument is larger than the length of the String, it is replaced with the length of the String.

If start is larger than end, they are swapped.

执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let len be the length of S.
Let intStart be ? ToInteger(start).
If end is undefined, let intEnd be len; else let intEnd be ? ToInteger(end).
Let finalStart be min(max(intStart, 0), len).
Let finalEnd be min(max(intEnd, 0), len).
Let from be min(finalStart, finalEnd).
Let to be max(finalStart, finalEnd).
Return the String 值 whose length is to - from, containing 代码单元 from S, namely the 代码单元 with indices from through to - 1, in ascending order.

Note

The substring function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.22String.prototype.toLocaleLowerCase ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the toLocaleLowerCase method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleLowerCase method is used.

This function interprets a String 值 as a sequence of UTF-16 encoded code points, as described in 6.1.4.

This function works exactly the same as toLowerCase except that its result is intended to yield the correct result for the host environment's current locale, rather than a locale-independent result. There will only be a difference in the few cases (例如 Turkish) where the rules for that language conflict with the regular Unicode case mappings.

Note

The toLocaleLowerCase function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.23String.prototype.toLocaleUpperCase ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the toLocaleUpperCase method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleUpperCase method is used.

This function interprets a String 值 as a sequence of UTF-16 encoded code points, as described in 6.1.4.

This function works exactly the same as toUpperCase except that its result is intended to yield the correct result for the host environment's current locale, rather than a locale-independent result. There will only be a difference in the few cases (例如 Turkish) where the rules for that language conflict with the regular Unicode case mappings.

Note

The toLocaleUpperCase function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.24String.prototype.toLowerCase ( )

This function interprets a String 值 as a sequence of UTF-16 encoded code points, as described in 6.1.4. 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let cpList be a List containing in order the code points as defined in 6.1.4 of S, starting at the first element of S.
Let cuList be a List where the elements are the result of toLowercase(cplist), according to the Unicode Default Case Conversion 算法.
Let L be the String 值 whose elements are the UTF16Encoding of the code points of cuList.
Return L.

The result must be derived according to the locale-insensitive case mappings in the Unicode Character Database (this explicitly includes not only the UnicodeData.txt file, but also all locale-insensitive mappings in the SpecialCasings.txt file that accompanies it).

Note 1

The case mapping of some code points may produce multiple code points. In this case the result String may not be the same length as the source String. Because both toUpperCase and toLowerCase have context-sensitive behaviour, the functions are not symmetrical. In other words, s.toUpperCase().toLowerCase() is not necessarily equal to s.toLowerCase().

Note 2

The toLowerCase function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.25String.prototype.toString ( )

When the toString method is called, 执行如下:

Return ? thisStringValue(this value).

Note

For a String 对象, the toString method happens to return the same thing as the valueOf method.

21.1.3.26String.prototype.toUpperCase ( )

This function interprets a String 值 as a sequence of UTF-16 encoded code points, as described in 6.1.4.

This function behaves in exactly the same way as String.prototype.toLowerCase, except that the String is mapped using the toUppercase 算法 of the Unicode Default Case Conversion.

Note

The toUpperCase function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.27String.prototype.trim ( )

This function interprets a String 值 as a sequence of UTF-16 encoded code points, as described in 6.1.4.

执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let T be the String 值 that is a copy of S with both leading and trailing 空白 removed. The definition of 空白 is the union of WhiteSpace and LineTerminator. When determining whether a Unicode 码点 is in Unicode general category “Space_Separator” (“Zs”), 代码单元 sequences are interpreted as UTF-16 encoded 码点 sequences as specified in 6.1.4.
Return T.

Note

The trim function 是故意通用的; 不需要 its this value be a String 对象. Therefore, 它可以转换为其它对象类型的方法而被使用.

21.1.3.28String.prototype.valueOf ( )

When the valueOf method is called, 执行如下:

Return ? thisStringValue(this value).

21.1.3.29String.prototype [ @@迭代器 ] ( )

When the @@迭代器 method is called it returns an 迭代器 object (25.1.1.2) that iterates over the code points of a String 值, returning each 码点 as a String 值. 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Return CreateStringIterator(S).

The value of the name property of this function is "[Symbol.迭代器]".

21.1.4String 实例的属性

String 实例 are String 外来对象 and have the 内部方法 specified for such objects. String 实例继承属性 from the String 原型对象. String 实例 also have a [[StringData]] 内部属性.

String 实例 have a length property, 和一套带有整数索引名的可枚举属性.

21.1.4.1length

有字符型对象表示的字符串值中的元素个数.

一旦一个 String 对象被初始化, 该属性就不会再发生变化. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

21.1.5String 迭代器对象

String 迭代器是一个对象, that represents a specific iteration over some specific String instance object. There is not a named 构造器 for String 迭代器对象. Instead, String 迭代器对象 are created by calling certain methods of String instance objects.

21.1.5.1CreateStringIterator ( `string` )

Several methods of 字符串对象 return 迭代器对象. The 抽象操作 CreateStringIterator with argument string is used to create such 迭代器对象. It 执行如下:

Assert: Type(string) is String.
Let 迭代器 be ObjectCreate(%StringIteratorPrototype%, « [[IteratedString]], [[StringIteratorNextIndex]] »).
Set 迭代器.[[IteratedString]] to string.
Set 迭代器.[[StringIteratorNextIndex]] to 0.
Return 迭代器.

21.1.5.2The %StringIteratorPrototype% Object

All String 迭代器对象继承属性 from the %StringIteratorPrototype% 内部对象. The %StringIteratorPrototype% object is an 普通对象 and its [[Prototype]] 内部属性 is the %IteratorPrototype% 内部对象. In addition, %StringIteratorPrototype% 有以下属性:

21.1.5.2.1%StringIteratorPrototype%.next ( )

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have all of the 内部属性 of a String 迭代器 Instance (21.1.5.3), 抛出一个 TypeError 异常.
Let s be O.[[IteratedString]].
If s is undefined, return CreateIterResultObject(undefined, true).
Let position be O.[[StringIteratorNextIndex]].
Let len be the length of s.
If position ≥ len, then
1. Set O.[[IteratedString]] to undefined.
2. Return CreateIterResultObject(undefined, true).
Let first be the 数字值 of the 代码单元 at index position within s.
If first < 0xD800 or first > 0xDBFF or position+1 = len, let resultString be the String 值 consisting of the single 代码单元 first.
Else,
1. Let second be the 数字值 of the 代码单元 at index position+1 within the String S.
2. If second < 0xDC00 or second > 0xDFFF, let resultString be the String 值 consisting of the single 代码单元 first.
3. Else, let resultString be the string-concatenation of the 代码单元 first and the 代码单元 second.
Let resultSize be the number of 代码单元 in resultString.
Set O.[[StringIteratorNextIndex]] to position + resultSize.
Return CreateIterResultObject(resultString, false).

21.1.5.2.2%StringIteratorPrototype% [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "String 迭代器".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

21.1.5.3String 迭代器实例的属性

String 迭代器实例 are 普通对象 that 继承属性 from the %StringIteratorPrototype% 内部对象. String 迭代器实例 are initially created with the 内部属性 listed in Table 49.

Table 49: 内部属性 of String 迭代器实例

内部属性	Description
[[IteratedString]]	The String 值 whose elements are being iterated.
[[StringIteratorNextIndex]]	The 整数索引 of the next string index to be examined by this iteration.

21.2RegExp (正则表达式) 对象

RegExp 对象包含一个正则表达式及与其相关联的标志.

Note

正则表达式的形式和功能是以 Perl 5 程序语言的正则表达式设施为蓝本的.

21.2.1模式

The RegExp 构造器对输入模式字符串应用以下文法. 一个错误会发生，如果文法无法将字符串解释为一个延伸 of Pattern.

Syntax

[U, N]

[?U, ?N]

[U, N]

[?U, ?N]

[?U, ?N]

[?U, ?N]

[U, N]

[empty]

[?U, ?N]

[?U, ?N]

[U, N]

[?U, ?N]

[?U, ?N]

[?U, ?N]

[U, N]

(

[?U, ?N]

)

(

[?U, ?N]

)

(

[?U, ?N]

)

(

[?U, ?N]

)

QuantifierPrefix

{

}

{

}

{

}

[U, N]

[?U, ?N]

[?U]

(

GroupSpecifier

[?U]

[?U, ?N]

)

(

[?U, ?N]

)

one of

(

)

[

]

{

}

PatternCharacter

but not SyntaxCharacter

[U, N]

[?U]

[?U]

[+N]

[?U]

[U]

[lookahead ∉ DecimalDigit]

[?U]

[?U]

one of

one of

[U]

[empty]

[?U]

[U]

[?U]

[U]

[?U]

RegExpIdentifierName

[?U]

[?U]

[U]

UnicodeIDStart

[?U]

[U]

[?U]

<ZWNJ>

<ZWJ>

[U]

[+U]

[+U]

[+U]

[+U]

[~U]

[+U]

}

Each \u TrailSurrogate for which the choice of associated u LeadSurrogate is ambiguous shall be associated with the nearest possible u LeadSurrogate that would otherwise have no corresponding \u TrailSurrogate.

LeadSurrogate

but only if the SV of Hex4Digits is in the inclusive range 0xD800 to 0xDBFF

but only if the SV of Hex4Digits is in the inclusive range 0xDC00 to 0xDFFF

NonSurrogate

but only if the SV of Hex4Digits is not in the inclusive range 0xD800 to 0xDFFF

[U]

[+U]

[+U]

[~U]

but not UnicodeIDContinue

opt

[lookahead ∉ DecimalDigit]

[U]

[+U]

}

[+U]

}

LoneUnicodePropertyNameOrValue

UnicodePropertyName

UnicodePropertyValue

UnicodePropertyName

UnicodePropertyNameCharacter

opt

UnicodePropertyValue

LoneUnicodePropertyNameOrValue

UnicodePropertyValueCharacter

UnicodePropertyValueCharacter

opt

UnicodePropertyNameCharacter

CharacterClass

[U]

[

[lookahead ∉ { ^ }]

[?U]

]

[

[?U]

]

[U]

[empty]

[?U]

[U]

[?U]

[?U]

[?U]

[?U]

[?U]

[?U]

[U]

[?U]

[?U]

[?U]

[?U]

[?U]

[?U]

[U]

[?U]

[U]

but not one of \ or ] or -

[?U]

[U]

[+U]

[?U]

[?U]

21.2.1.1静态语义: 早期错误

Pattern

这是一个句法错误如果 NcapturingParens ≥ 2³²-1.
这是一个句法错误如果 Pattern contains multiple GroupSpecifiers whose enclosed RegExpIdentifierNames have the same 字符值.

QuantifierPrefix

{

}

这是一个句法错误如果 the MV of the first DecimalDigits is larger than the MV of the second DecimalDigits.

GroupName

这是一个句法错误如果 the enclosing Pattern does not contain a GroupSpecifier with an enclosed RegExpIdentifierName whose 字符值 equals the 字符值 of the RegExpIdentifierName of this production's GroupName.

这是一个句法错误如果 the 捕获分组号 of DecimalEscape is larger than NcapturingParens (21.2.2.1).

NonemptyClassRanges

这是一个句法错误如果 IsCharacterClass of the first ClassAtom is true or IsCharacterClass of the second ClassAtom is true.
这是一个句法错误如果 IsCharacterClass of the first ClassAtom is false and IsCharacterClass of the second ClassAtom is false and the 字符值 of the first ClassAtom is larger than the 字符值 of the second ClassAtom.

这是一个句法错误如果 IsCharacterClass of ClassAtomNoDash is true or IsCharacterClass of ClassAtom is true.
这是一个句法错误如果 IsCharacterClass of ClassAtomNoDash is false and IsCharacterClass of ClassAtom is false and the 字符值 of ClassAtomNoDash is larger than the 字符值 of ClassAtom.

[U]

[?U]

这是一个句法错误如果 SV(RegExpUnicodeEscapeSequence) is none of "$", or "_", or the UTF16Encoding of a 码点 matched by the UnicodeIDStart 词法 production.

[U]

[?U]

这是一个句法错误如果 SV(RegExpUnicodeEscapeSequence) is none of "$", or "_", or the UTF16Encoding of either <ZWNJ> or <ZWJ>, or the UTF16Encoding of a Unicode 码点 that would be matched by the UnicodeIDContinue 词法 production.

UnicodePropertyName

UnicodePropertyValue

这是一个句法错误如果 the List of Unicode code points that is 源文本 of UnicodePropertyName is not identical to a List of Unicode code points that is a Unicode 属性名 or property alias listed in the “属性名 and aliases” column of Table 51.
这是一个句法错误如果 the List of Unicode code points that is 源文本 of UnicodePropertyValue is not identical to a List of Unicode code points that is a value or value alias for the Unicode property or property alias given by 源文本 of UnicodePropertyName listed in the “Property value and aliases” column of the corresponding tables Table 53 or Table 54.

LoneUnicodePropertyNameOrValue

这是一个句法错误如果 the List of Unicode code points that is 源文本 of LoneUnicodePropertyNameOrValue is not identical to a List of Unicode code points that is a Unicode general category or general category alias listed in the “Property value and aliases” column of Table 53, nor a binary property or binary property alias listed in the “属性名 and aliases” column of Table 52.

21.2.1.2静态语义: 捕获分组号

Return the MV of NonZeroDigit.

Let n be the number of code points in DecimalDigits.
Return (the MV of NonZeroDigit × 10ⁿ) plus the MV of DecimalDigits.

The definitions of “the MV of NonZeroDigit” and “the MV of DecimalDigits” are in 11.8.3.

21.2.1.3静态语义: IsCharacterClass

but not one of \ or ] or -

Return false.

Return true.

21.2.1.4静态语义: 字符值

Return the 码点 value of U+002D (HYPHEN-MINUS).

but not one of \ or ] or -

Let ch be the 码点 matched by SourceCharacter.
Return the 码点 value of ch.

Return the 码点 value of U+0008 (BACKSPACE).

Return the 码点 value of U+002D (HYPHEN-MINUS).

ControlEscape

Return the 码点 value according to Table 50.

Table 50: ControlEscape 码点 Values

ControlEscape	码点 Value	码点	Unicode Name	Symbol
`t`	9	`U+0009`	CHARACTER TABULATION	<HT>
`n`	10	`U+000A`	LINE FEED (LF)	<LF>
`v`	11	`U+000B`	LINE TABULATION	<VT>
`f`	12	`U+000C`	FORM FEED (FF)	<FF>
`r`	13	`U+000D`	CARRIAGE RETURN (CR)	<CR>

Let ch be the 码点 matched by ControlLetter.
Let i be ch's 码点 value.
Return the remainder of dividing i by 32.

[lookahead ∉ DecimalDigit]

Return the 码点 value of U+0000 (NULL).

Note

\0 represents the <NUL> character and cannot be followed by a decimal digit.

Return the 数字值 of the 代码单元 that is the SV of HexEscapeSequence.

LeadSurrogate

Let lead be the 字符值 of LeadSurrogate.
Let trail be the 字符值 of TrailSurrogate.
Let cp be UTF16Decode(lead, trail).
Return the 码点 value of cp.

LeadSurrogate

Return the 字符值 of LeadSurrogate.

Return the 字符值 of TrailSurrogate.

NonSurrogate

Return the 字符值 of NonSurrogate.

Return the MV of Hex4Digits.

CodePoint

}

Return the MV of CodePoint.

Return the MV of HexDigits.

Let ch be the 码点 matched by IdentityEscape.
Return the 码点 value of ch.

21.2.1.5静态语义: 源文本

UnicodePropertyNameCharacter

opt

UnicodePropertyValueCharacter

opt

Return the List, in 源文本 order, of Unicode code points in the 源文本 matched by this production.

21.2.1.6静态语义: 字符值

RegExpIdentifierName

[U]

[?U]

RegExpIdentifierName

[?U]

[?U]

Return the String 值 consisting of the sequence of 代码单元 corresponding to RegExpIdentifierName. In determining the sequence any occurrences of \ RegExpUnicodeEscapeSequence are first replaced with the 码点 represented by the RegExpUnicodeEscapeSequence and then the code points of the entire RegExpIdentifierName are converted to 代码单元 by UTF16Encoding each 码点.

21.2.2模式语义

正则表达式模式 is converted into an internal procedure using the process described below. An 实现 is encouraged to use more efficient 算法 than the ones listed below, as long as the results are the same. The internal procedure is used as the value of a RegExp 对象's [[RegExpMatcher]] 内部属性.

A Pattern is either a BMP pattern or a Unicode pattern depending upon whether or not its associated flags contain a "u". A BMP pattern matches against a String interpreted as consisting of a sequence of 16-bit values that are Unicode code points in the range of the Basic Multilingual Plane. A Unicode pattern matches against a String interpreted as consisting of Unicode code points encoded using UTF-16. In the context of describing the behaviour of a BMP pattern “character” means a single 16-bit Unicode BMP 码点. In the context of describing the behaviour of a Unicode pattern “character” means a UTF-16 encoded 码点 (6.1.4). In either context, “character value” means the 数字值 of the corresponding non-encoded 码点.

The syntax and 语义 of Pattern is defined as if the source code for the Pattern was a List of SourceCharacter values where each SourceCharacter corresponds to a Unicode 码点. If a BMP pattern contains a non-BMP SourceCharacter the entire pattern is encoded using UTF-16 and the individual 代码单元 of that encoding are used as the elements of the List.

Note

例如, consider a pattern expressed in 源文本 as the single non-BMP character U+1D11E (MUSICAL SYMBOL G CLEF). Interpreted as a Unicode pattern, it would be a single element (character) List consisting of the single 码点 0x1D11E. However, interpreted as a BMP pattern, it is first UTF-16 encoded to produce a two element List consisting of the 代码单元 0xD834 and 0xDD1E.

模式 are passed to the RegExp 构造器 as ES String values in which non-BMP characters are UTF-16 encoded. 例如, the single character MUSICAL SYMBOL G CLEF pattern, expressed as a String 值, is a String of length 2 whose elements were the 代码单元 0xD834 and 0xDD1E. So no further translation of the string would be necessary to process it as a BMP pattern consisting of two pattern characters. However, to process it as a Unicode pattern UTF16Decode must be used in producing a List consisting of a single pattern character, the 码点 U+1D11E.

An 实现 may not actually perform such translations to or from UTF-16, but the 语义 of this specification requires that the result of pattern matching be as if such translations were performed.

21.2.2.1Notation

The descriptions below use the following variables:

Input is a List consisting of all of the characters, in order, of the String being matched by the 正则表达式 pattern. Each character is either a 代码单元 or a 码点, depending upon the kind of pattern involved. The notation Input[n] means the n^th character of Input, where n can range between 0 (inclusive) and InputLength (exclusive).
InputLength is the number of characters in Input.
NcapturingParens is the total number of left-capturing parentheses (i.e. the total number of Atom::(GroupSpecifierDisjunction) 解析节点) in the pattern. A left-capturing parenthesis is any ( pattern character that is matched by the ( terminal of the Atom::(GroupSpecifierDisjunction) production.
DotAll is true if the RegExp 对象's [[OriginalFlags]] 内部属性 contains "s" and otherwise is false.
IgnoreCase is true if the RegExp 对象's [[OriginalFlags]] 内部属性 contains "i" and otherwise is false.
Multiline is true if the RegExp 对象's [[OriginalFlags]] 内部属性 contains "m" and otherwise is false.
Unicode is true if the RegExp 对象's [[OriginalFlags]] 内部属性 contains "u" and otherwise is false.

Furthermore, the descriptions below use the following internal 数据结构:

A CharSet is a mathematical set of characters, either 代码单元 or code points depending up the state of the Unicode flag. “All characters” means either all 代码单元 values or all 码点 values also depending upon the state if Unicode.
A State is an ordered pair (endIndex, captures) where endIndex is an integer and captures is a List of NcapturingParens values. States are used to represent partial match states in the 正则表达式 matching 算法. The endIndex is one plus the index of the last input character matched so far by the pattern, while captures holds the results of capturing parentheses. The n^th element of captures is either a List that represents the value obtained by the n^th set of capturing parentheses or undefined if the n^th set of capturing parentheses hasn't been reached yet. Due to backtracking, many States may be in use at any time during the matching process.
A MatchResult is either a State or the special token failure that indicates that the match failed.
A Continuation procedure is an internal closure (i.e. an internal procedure with some arguments already bound to values) that takes one State argument and returns a MatchResult result. If an internal closure references variables which are bound in the function that creates the closure, the closure uses the values that these variables had at the time the closure was created. The Continuation attempts to match the remaining portion (specified by the closure's already-bound arguments) of the pattern against Input, starting at the intermediate state given by its State argument. If the match succeeds, the Continuation returns the final State that it reached; if the match fails, the Continuation returns failure.
A Matcher procedure is an internal closure that takes two arguments — a State and a Continuation — and returns a MatchResult result. A Matcher attempts to match a middle subpattern (specified by the closure's already-bound arguments) of the pattern against Input, starting at the intermediate state given by its State argument. The Continuation argument should be a closure that matches the rest of the pattern. After matching the subpattern of a pattern to obtain a new State, the Matcher then calls Continuation on that new State to test if the rest of the pattern can match as well. If it can, the Matcher returns the State returned by Continuation; if not, the Matcher may try different choices at its choice points, repeatedly calling Continuation until it either succeeds or all possibilities have been exhausted.
An AssertionTester procedure is an internal closure that takes a State argument and returns a Boolean result. The assertion tester tests a specific condition (specified by the closure's already-bound arguments) against the current place in Input and returns true if the condition matched or false if not.

21.2.2.2Pattern

The production Pattern::Disjunction evaluates as follows:

Evaluate Disjunction with +1 as its direction argument to obtain a Matcher m.
Return an internal closure that takes two arguments, a String str and an integer index, and 执行如下:
1. Assert: index ≤ the length of str.
2. If Unicode is true, let Input be a List consisting of the sequence of code points of str interpreted as a UTF-16 encoded (6.1.4) Unicode string. Otherwise, let Input be a List consisting of the sequence of 代码单元 that are the elements of str. Input will be used throughout the 算法 in 21.2.2. Each element of Input is considered to be a character.
3. Let InputLength be the number of characters contained in Input. This variable will be used throughout the 算法 in 21.2.2.
4. Let listIndex be the index into Input of the character that was obtained from element index of str.
5. Let c be a Continuation that always returns its State argument as a successful MatchResult.
6. Let cap be a List of NcapturingParens undefined values, indexed 1 through NcapturingParens.
7. Let x be the State (listIndex, cap).
8. Call m(x, c) and return its result.

Note

A Pattern evaluates (“compiles”) to an internal procedure value. RegExpBuiltinExec can then apply this procedure to a String and an offset within the String to determine whether the pattern would match starting at exactly that offset within the String, and, if it does match, what the values of the capturing parentheses would be. The 算法 in 21.2.2 are designed so that compiling a pattern may 抛出一个 SyntaxError 异常; on the other hand, once the pattern is successfully compiled, applying the resulting internal procedure to find a match in a String cannot 抛出一个异常 (except for any host-defined exceptions that can occur anywhere 例如 out-of-memory).

21.2.2.3Disjunction

With parameter direction.

The production Disjunction::Alternative evaluates as follows:

Evaluate Alternative to obtain a Matcher m.
Return m.

The production Disjunction::Alternative|Disjunction evaluates as follows:

Evaluate Alternative with argument direction to obtain a Matcher m1.
Evaluate Disjunction with argument direction to obtain a Matcher m2.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
1. Call m1(x, c) and let r be its result.
2. If r is not failure, return r.
3. Call m2(x, c) and return its result.

Note

The | 正则表达式运算符 separates two alternatives. The pattern first tries to match the left Alternative (followed by the sequel of the 正则表达式); if it fails, it tries to match the right Disjunction (followed by the sequel of the 正则表达式). If the left Alternative, the right Disjunction, and the sequel all have choice points, all choices in the sequel are tried before moving on to the next choice in the left Alternative. If choices in the left Alternative are exhausted, the right Disjunction is tried instead of the left Alternative. Any capturing parentheses inside a portion of the pattern skipped by | produce undefined values instead of Strings. Thus, 例如,

/a|ab/.exec("abc")

returns the result "a" and not "ab". Moreover,

/((a)|(ab))((c)|(bc))/.exec("abc")

returns the array

["abc", "a", "a", undefined, "bc", undefined, "bc"]

and not

["abc", "ab", undefined, "ab", "c", "c", undefined]

The order in which the two alternatives are tried is independent of the value of direction.

21.2.2.4Alternative

With parameter direction.

The production Alternative::[empty] evaluates as follows:

Return a Matcher that takes two arguments, a State x and a Continuation c, and returns the result of calling c(x).

The production Alternative::AlternativeTerm evaluates as follows:

Evaluate Alternative with argument direction to obtain a Matcher m1.
Evaluate Term with argument direction to obtain a Matcher m2.
If direction is equal to +1, then
1. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
  1. Let d be a Continuation that takes a State argument y and returns the result of calling m2(y, c).
  2. Call m1(x, d) and return its result.
Else,
1. Assert: direction is equal to -1.
2. Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
  1. Let d be a Continuation that takes a State argument y and returns the result of calling m1(y, c).
  2. Call m2(x, d) and return its result.

Note

Consecutive Terms try to simultaneously match consecutive portions of Input. When direction is equal to +1, if the left Alternative, the right Term, and the sequel of the 正则表达式 all have choice points, all choices in the sequel are tried before moving on to the next choice in the right Term, and all choices in the right Term are tried before moving on to the next choice in the left Alternative. When direction is equal to -1, the 估值 order of Alternative and Term are reversed.

21.2.2.5Term

With parameter direction.

The production Term::Assertion evaluates as follows:

Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
1. Evaluate Assertion to obtain an AssertionTester t.
2. Call t(x) and let r be the resulting Boolean 值.
3. If r is false, return failure.
4. Call c(x) and return its result.

Note

The AssertionTester is independent of direction.

The production Term::Atom evaluates as follows:

Return the Matcher that is the result of evaluating Atom with argument direction.

The production Term::AtomQuantifier evaluates as follows:

Evaluate Atom with argument direction to obtain a Matcher m.
Evaluate Quantifier to obtain the three results: an integer min, an integer (or ∞) max, and Boolean greedy.
Assert: If max is finite, then max is not less than min.
Let parenIndex be the number of left-capturing parentheses in the entire 正则表达式 that occur to the left of this Term. This is the total number of Atom::(GroupSpecifierDisjunction) 解析节点 prior to or enclosing this Term.
Let parenCount be the number of left-capturing parentheses in Atom. This is the total number of Atom::(GroupSpecifierDisjunction) 解析节点 enclosed by Atom.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
1. Call RepeatMatcher(m, min, max, greedy, x, c, parenIndex, parenCount) and return its result.

21.2.2.5.1运行时语义: RepeatMatcher ( `m`, `min`, `max`, `greedy`, `x`, `c`, `parenIndex`, `parenCount` )

The 抽象操作 RepeatMatcher takes eight parameters, a Matcher m, an integer min, an integer (or ∞) max, a Boolean greedy, a State x, a Continuation c, an integer parenIndex, and an integer parenCount, and 执行如下:

If max is zero, return c(x).
Let d be an internal Continuation closure that takes one State argument y and 执行如下 when evaluated:
1. If min is zero and y's endIndex is equal to x's endIndex, return failure.
2. If min is zero, let min2 be zero; otherwise let min2 be min-1.
3. If max is ∞, let max2 be ∞; otherwise let max2 be max-1.
4. Call RepeatMatcher(m, min2, max2, greedy, y, c, parenIndex, parenCount) and return its result.
Let cap be a copy of x's captures List.
For each integer k that satisfies parenIndex < k and k ≤ parenIndex+parenCount, set cap[k] to undefined.
Let e be x's endIndex.
Let xr be the State (e, cap).
If min is not zero, return m(xr, d).
If greedy is false, then
1. Call c(x) and let z be its result.
2. If z is not failure, return z.
3. Call m(xr, d) and return its result.
Call m(xr, d) and let z be its result.
If z is not failure, return z.
Call c(x) and return its result.

Note 1

An Atom followed by a Quantifier is repeated the number of times specified by the Quantifier. A Quantifier can be non-greedy, in which case the Atom pattern is repeated as few times as possible while still matching the sequel, or it can be greedy, in which case the Atom pattern is repeated as many times as possible while still matching the sequel. The Atom pattern is repeated rather than the input character sequence that it matches, so different repetitions of the Atom can match different input substrings.

Note 2

If the Atom and the sequel of the 正则表达式 all have choice points, the Atom is first matched as many (or as few, if non-greedy) times as possible. All choices in the sequel are tried before moving on to the next choice in the last repetition of Atom. All choices in the last (n^th) repetition of Atom are tried before moving on to the next choice in the next-to-last (n-1)^st repetition of Atom; at which point it may turn out that more or fewer repetitions of Atom are now possible; these are exhausted (again, starting with either as few or as many as possible) before moving on to the next choice in the (n-1)^st repetition of Atom and so on.

Compare

/a[a-z]{2,4}/.exec("abcdefghi")

which returns "abcde" with

/a[a-z]{2,4}?/.exec("abcdefghi")

which returns "abc".

Consider also

/(aa|aabaac|ba|b|c)*/.exec("aabaac")

which, by the choice point ordering above, returns the array

["aaba", "ba"]

and not any of:

["aabaac", "aabaac"]
                            ["aabaac", "c"]

The above ordering of choice points can be used to write a 正则表达式 that calculates the greatest common divisor of two numbers (represented in 一元 notation). The following example calculates the gcd of 10 and 15:

"aaaaaaaaaa,aaaaaaaaaaaaaaa".replace(/^(a+)\1*,\1+$/,"$1")

which returns the gcd in 一元 notation "aaaaa".

Note 3

Step 4 of the RepeatMatcher clears Atom's captures each time Atom is repeated. We can see its behaviour in the 正则表达式

/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")

which returns the array

["zaacbbbcac", "z", "ac", "a", undefined, "c"]

and not

["zaacbbbcac", "z", "ac", "a", "bbb", "c"]

because each iteration of the outermost * clears all captured Strings contained in the quantified Atom, which in this case includes capture Strings numbered 2, 3, 4, and 5.

Note 4

Step 1 of the RepeatMatcher's d closure states that, once the minimum number of repetitions has been satisfied, any more expansions of Atom that match the empty character sequence are not considered for further repetitions. This prevents the 正则表达式 engine from falling into an infinite loop on 模式例如:

/(a*)*/.exec("b")

or the slightly more complicated:

/(a*)b\1+/.exec("baaaac")

which returns the array

["b", ""]

21.2.2.6Assertion

The production Assertion::^ evaluates as follows:

Return an internal AssertionTester closure that takes a State argument x and 执行如下 when evaluated:
1. Let e be x's endIndex.
2. If e is zero, return true.
3. If Multiline is false, return false.
4. If the character Input[e-1] is one of LineTerminator, return true.
5. Return false.

Note

Even when the y flag is used with a pattern, ^ always matches only at the beginning of Input, or (if Multiline is true) at the beginning of a line.

The production Assertion::$ evaluates as follows:

Return an internal AssertionTester closure that takes a State argument x and 执行如下 when evaluated:
1. Let e be x's endIndex.
2. If e is equal to InputLength, return true.
3. If Multiline is false, return false.
4. If the character Input[e] is one of LineTerminator, return true.
5. Return false.

The production Assertion::\b evaluates as follows:

Return an internal AssertionTester closure that takes a State argument x and 执行如下 when evaluated:
1. Let e be x's endIndex.
2. Call IsWordChar(e-1) and let a be the Boolean result.
3. Call IsWordChar(e) and let b be the Boolean result.
4. If a is true and b is false, return true.
5. If a is false and b is true, return true.
6. Return false.

The production Assertion::\B evaluates as follows:

Return an internal AssertionTester closure that takes a State argument x and 执行如下 when evaluated:
1. Let e be x's endIndex.
2. Call IsWordChar(e-1) and let a be the Boolean result.
3. Call IsWordChar(e) and let b be the Boolean result.
4. If a is true and b is false, return false.
5. If a is false and b is true, return false.
6. Return true.

The production Assertion::(?=Disjunction) evaluates as follows:

Evaluate Disjunction with +1 as its direction argument to obtain a Matcher m.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let d be a Continuation that always returns its State argument as a successful MatchResult.
2. Call m(x, d) and let r be its result.
3. If r is failure, return failure.
4. Let y be r's State.
5. Let cap be y's captures List.
6. Let xe be x's endIndex.
7. Let z be the State (xe, cap).
8. Call c(z) and return its result.

The production Assertion::(?!Disjunction) evaluates as follows:

Evaluate Disjunction with +1 as its direction argument to obtain a Matcher m.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let d be a Continuation that always returns its State argument as a successful MatchResult.
2. Call m(x, d) and let r be its result.
3. If r is not failure, return failure.
4. Call c(x) and return its result.

The production Assertion::(?<=Disjunction) evaluates as follows:

Evaluate Disjunction with -1 as its direction argument to obtain a Matcher m.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let d be a Continuation that always returns its State argument as a successful MatchResult.
2. Call m(x, d) and let r be its result.
3. If r is failure, return failure.
4. Let y be r's State.
5. Let cap be y's captures List.
6. Let xe be x's endIndex.
7. Let z be the State (xe, cap).
8. Call c(z) and return its result.

The production Assertion::(?<!Disjunction) evaluates as follows:

Evaluate Disjunction with -1 as its direction argument to obtain a Matcher m.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let d be a Continuation that always returns its State argument as a successful MatchResult.
2. Call m(x, d) and let r be its result.
3. If r is not failure, return failure.
4. Call c(x) and return its result.

21.2.2.6.1运行时语义: WordCharacters ( )

The 抽象操作 WordCharacters 执行如下:

Let A be a set of characters containing the sixty-three characters:

a b c d e f g h i j k l m n o p q r s t u v w x y z

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

0 1 2 3 4 5 6 7 8 9 _

Let U be an empty set.
For each character c not in set A where Canonicalize(c) is in A, add c to U.
Assert: Unless Unicode and IgnoreCase are both true, U is empty.
Add the characters in set U to set A.
Return A.

21.2.2.6.2运行时语义: IsWordChar ( `e` )

The 抽象操作 IsWordChar takes an integer parameter e and 执行如下:

If e is -1 or e is InputLength, return false.
Let c be the character Input[e].
Let wordChars be the result of ! WordCharacters().
If c is in wordChars, return true.
Return false.

21.2.2.7Quantifier

The production Quantifier::QuantifierPrefix evaluates as follows:

Evaluate QuantifierPrefix to obtain the two results: an integer min and an integer (or ∞) max.
Return the three results min, max, and true.

The production Quantifier::QuantifierPrefix? evaluates as follows:

Evaluate QuantifierPrefix to obtain the two results: an integer min and an integer (or ∞) max.
Return the three results min, max, and false.

The production QuantifierPrefix::* evaluates as follows:

Return the two results 0 and ∞.

The production QuantifierPrefix::+ evaluates as follows:

Return the two results 1 and ∞.

The production QuantifierPrefix::? evaluates as follows:

Return the two results 0 and 1.

The production QuantifierPrefix::{DecimalDigits} evaluates as follows:

Let i be the MV of DecimalDigits (see 11.8.3).
Return the two results i and i.

The production QuantifierPrefix::{DecimalDigits,} evaluates as follows:

Let i be the MV of DecimalDigits.
Return the two results i and ∞.

The production QuantifierPrefix::{DecimalDigits,DecimalDigits} evaluates as follows:

Let i be the MV of the first DecimalDigits.
Let j be the MV of the second DecimalDigits.
Return the two results i and j.

21.2.2.8Atom

With parameter direction.

The production Atom::PatternCharacter evaluates as follows:

Let ch be the character matched by PatternCharacter.
Let A be a one-element CharSet containing the character ch.
Call CharacterSetMatcher(A, false, direction) and return its Matcher result.

The production Atom::. evaluates as follows:

If DotAll is true, then
1. Let A be the set of all characters.
Otherwise, let A be the set of all characters except LineTerminator.
Call CharacterSetMatcher(A, false, direction) and return its Matcher result.

The production Atom::\AtomEscape evaluates as follows:

Return the Matcher that is the result of evaluating AtomEscape with argument direction.

The production Atom::CharacterClass evaluates as follows:

Evaluate CharacterClass to obtain a CharSet A and a Boolean invert.
Call CharacterSetMatcher(A, invert, direction) and return its Matcher result.

The production Atom::(GroupSpecifierDisjunction) evaluates as follows:

Evaluate Disjunction with argument direction to obtain a Matcher m.
Let parenIndex be the number of left-capturing parentheses in the entire 正则表达式 that occur to the left of this Atom. This is the total number of Atom::(GroupSpecifierDisjunction) 解析节点 prior to or enclosing this Atom.
Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let d be an internal Continuation closure that takes one State argument y and 执行如下:
  1. Let cap be a copy of y's captures List.
  2. Let xe be x's endIndex.
  3. Let ye be y's endIndex.
  4. If direction is equal to +1, then
    1. Assert: xe ≤ ye.
    2. Let s be a new List whose elements are the characters of Input at indices xe (inclusive) through ye (exclusive).
  5. Else,
    1. Assert: direction is equal to -1.
    2. Assert: ye ≤ xe.
    3. Let s be a new List whose elements are the characters of Input at indices ye (inclusive) through xe (exclusive).
  6. Set cap[parenIndex+1] to s.
  7. Let z be the State (ye, cap).
  8. Call c(z) and return its result.
2. Call m(x, d) and return its result.

The production Atom::(?:Disjunction) evaluates as follows:

Return the Matcher that is the result of evaluating Disjunction with argument direction.

21.2.2.8.1运行时语义: CharacterSetMatcher ( `A`, `invert`, `direction` )

The 抽象操作 CharacterSetMatcher takes three arguments, a CharSet A, a Boolean flag invert, and an integer direction, and 执行如下:

Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下 when evaluated:
1. Let e be x's endIndex.
2. Let f be e + direction.
3. If f < 0 or f > InputLength, return failure.
4. Let index be min(e, f).
5. Let ch be the character Input[index].
6. Let cc be Canonicalize(ch).
7. If invert is false, then
  1. If there does not exist a member a of set A such that Canonicalize(a) is cc, return failure.
8. Else,
  1. Assert: invert is true.
  2. If there exists a member a of set A such that Canonicalize(a) is cc, return failure.
9. Let cap be x's captures List.
10. Let y be the State (f, cap).
11. Call c(y) and return its result.

21.2.2.8.2运行时语义: Canonicalize ( `ch` )

The 抽象操作 Canonicalize takes a character parameter ch and 执行如下:

If IgnoreCase is false, return ch.
If Unicode is true, then
1. If the file CaseFolding.txt of the Unicode Character Database provides a simple or common case folding mapping for ch, return the result of applying that mapping to ch.
2. Return ch.
Else,
1. Assert: ch is a UTF-16 代码单元.
2. Let s be the String 值 consisting of the single 代码单元 ch.
3. Let u be the same result produced as if by performing the 算法 for String.prototype.toUpperCase using s as the this value.
4. Assert: u is a String 值.
5. If u does not consist of a single 代码单元, return ch.
6. Let cu be u's single 代码单元 element.
7. If the 数字值 of ch ≥ 128 and the 数字值 of cu < 128, return ch.
8. Return cu.

Note 1

Parentheses of the form ( Disjunction ) serve both to group the components of the Disjunction pattern together and to save the result of the match. The result can be used either in a backreference (\ followed by a nonzero decimal number), referenced in a replace String, or returned as part of an array from the 正则表达式 matching internal procedure. To inhibit the capturing behaviour of parentheses, use the form (?: Disjunction ) instead.

Note 2

The form (?= Disjunction ) specifies a zero-width positive lookahead. In order for it to succeed, the pattern inside Disjunction must match at the current position, but the current position is not advanced before matching the sequel. If Disjunction can match at the current position in several ways, only the first one is tried. Unlike other 正则表达式 operators, there is no backtracking into a (?= form (this unusual behaviour is inherited from Perl). This only matters when the Disjunction contains capturing parentheses and the sequel of the pattern contains backreferences to those captures.

例如,

/(?=(a+))/.exec("baaabac")

matches the empty String immediately after the first b and therefore returns the array:

["", "aaa"]

To illustrate the lack of backtracking into the lookahead, consider:

/(?=(a+))a*b\1/.exec("baaabac")

This expression returns

["aba", "a"]

and not:

["aaaba", "a"]

Note 3

The form (?! Disjunction ) specifies a zero-width negative lookahead. In order for it to succeed, the pattern inside Disjunction must fail to match at the current position. The current position is not advanced before matching the sequel. Disjunction can contain capturing parentheses, but backreferences to them only make sense from within Disjunction itself. Backreferences to these capturing parentheses from elsewhere in the pattern always return undefined because the negative lookahead must fail for the pattern to succeed. 例如,

/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")

looks for an a not immediately followed by some positive number n of a's, a b, another n a's (specified by the first \2) and a c. The second \2 is outside the negative lookahead, so it matches against undefined and therefore always succeeds. The whole expression returns the array:

["baaabaac", "ba", undefined, "abaac"]

Note 4

In case-insignificant matches when Unicode is true, all characters are implicitly case-folded using the simple mapping provided by the Unicode standard immediately before they are compared. The simple mapping always maps to a single 码点, so it does not map, 例如, "ß" (U+00DF) to "SS". It may however map a 码点 outside the Basic Latin range to a character within, 例如, "ſ" (U+017F) to "s". Such characters are not mapped if Unicode is false. This prevents Unicode code points 例如 U+017F and U+212A from matching 正则表达式例如 /[a-z]/i, but they will match /[a-z]/ui.

21.2.2.8.3运行时语义: UnicodeMatchProperty ( `p` )

The 抽象操作 UnicodeMatchProperty takes a parameter p that is a List of Unicode code points and 执行如下:

Assert: p is a List of Unicode code points that is identical to a List of Unicode code points that is a Unicode 属性名 or property alias listed in the “属性名 and aliases” column of Table 51 or Table 52.
Let c be the canonical 属性名 of p as given in the “Canonical 属性名” column of the corresponding row.
Return the List of Unicode code points of c.

Implementations must support the Unicode property names and aliases listed in Table 51 and Table 52. To ensure interoperability, implementations must not support any other property names or aliases.

Note 1

例如, Script_Extensions (属性名) and scx (property alias) are valid, but script_extensions or Scx aren't.

Note 2

The listed properties form a superset of what UTS18 RL1.2 requires.

Table 51: Non-binary Unicode property aliases and their canonical property names

属性名 and aliases	Canonical 属性名
`General_Category` `gc`	`General_Category`
`Script` `sc`	`Script`
`Script_Extensions` `scx`	`Script_Extensions`

Table 52: Binary Unicode property aliases and their canonical property names

属性名 and aliases	Canonical 属性名
`ASCII`	`ASCII`
`ASCII_Hex_Digit` `AHex`	`ASCII_Hex_Digit`
`Alphabetic` `Alpha`	`Alphabetic`
`Any`	`Any`
`Assigned`	`Assigned`
`Bidi_Control` `Bidi_C`	`Bidi_Control`
`Bidi_Mirrored` `Bidi_M`	`Bidi_Mirrored`
`Case_Ignorable` `CI`	`Case_Ignorable`
`Cased`	`Cased`
`Changes_When_Casefolded` `CWCF`	`Changes_When_Casefolded`
`Changes_When_Casemapped` `CWCM`	`Changes_When_Casemapped`
`Changes_When_Lowercased` `CWL`	`Changes_When_Lowercased`
`Changes_When_NFKC_Casefolded` `CWKCF`	`Changes_When_NFKC_Casefolded`
`Changes_When_Titlecased` `CWT`	`Changes_When_Titlecased`
`Changes_When_Uppercased` `CWU`	`Changes_When_Uppercased`
`Dash`	`Dash`
`Default_Ignorable_Code_Point` `DI`	`Default_Ignorable_Code_Point`
`Deprecated` `Dep`	`Deprecated`
`Diacritic` `Dia`	`Diacritic`
`Emoji`	`Emoji`
`Emoji_Component`	`Emoji_Component`
`Emoji_Modifier`	`Emoji_Modifier`
`Emoji_Modifier_Base`	`Emoji_Modifier_Base`
`Emoji_Presentation`	`Emoji_Presentation`
`Extender` `Ext`	`Extender`
`Grapheme_Base` `Gr_Base`	`Grapheme_Base`
`Grapheme_Extend` `Gr_Ext`	`Grapheme_Extend`
`Hex_Digit` `Hex`	`Hex_Digit`
`IDS_Binary_Operator` `IDSB`	`IDS_Binary_Operator`
`IDS_Trinary_Operator` `IDST`	`IDS_Trinary_Operator`
`ID_Continue` `IDC`	`ID_Continue`
`ID_Start` `IDS`	`ID_Start`
`Ideographic` `Ideo`	`Ideographic`
`Join_Control` `Join_C`	`Join_Control`
`Logical_Order_Exception` `LOE`	`Logical_Order_Exception`
`Lowercase` `Lower`	`Lowercase`
`Math`	`Math`
`Noncharacter_Code_Point` `NChar`	`Noncharacter_Code_Point`
`Pattern_Syntax` `Pat_Syn`	`Pattern_Syntax`
`Pattern_White_Space` `Pat_WS`	`Pattern_White_Space`
`Quotation_Mark` `QMark`	`Quotation_Mark`
`Radical`	`Radical`
`Regional_Indicator` `RI`	`Regional_Indicator`
`Sentence_Terminal` `STerm`	`Sentence_Terminal`
`Soft_Dotted` `SD`	`Soft_Dotted`
`Terminal_Punctuation` `Term`	`Terminal_Punctuation`
`Unified_Ideograph` `UIdeo`	`Unified_Ideograph`
`Uppercase` `Upper`	`Uppercase`
`Variation_Selector` `VS`	`Variation_Selector`
`White_Space` `space`	`White_Space`
`XID_Continue` `XIDC`	`XID_Continue`
`XID_Start` `XIDS`	`XID_Start`

21.2.2.8.4运行时语义: UnicodeMatchPropertyValue ( `p`, `v` )

The 抽象操作 UnicodeMatchPropertyValue takes two parameters p and v, each of which is a List of Unicode code points, and 执行如下:

Assert: p is a List of Unicode code points that is identical to a List of Unicode code points that is a canonical, unaliased Unicode 属性名 listed in the “Canonical 属性名” column of Table 51.
Assert: v is a List of Unicode code points that is identical to a List of Unicode code points that is a property value or property value alias for Unicode property p listed in the “Property value and aliases” column of Table 53 or Table 54.
Let value be the canonical property value of v as given in the “Canonical property value” column of the corresponding row.
Return the List of Unicode code points of value.

Implementations must support the Unicode property value names and aliases listed in Table 53 and Table 54. To ensure interoperability, implementations must not support any other property value names or aliases.

Note 1

例如, Xpeo and Old_Persian are valid Script_Extension values, but xpeo and Old Persian aren't.

Note 2

This 算法 differs from the matching rules for symbolic values listed in UAX44: case, 空白, U+002D (HYPHEN-MINUS), and U+005F (LOW LINE) are not ignored, and the Is prefix is not supported.

Table 53: Value aliases and canonical values for the Unicode property General_Category

Property value and aliases	Canonical property value
`Cased_Letter` `LC`	`Cased_Letter`
`Close_Punctuation` `Pe`	`Close_Punctuation`
`Connector_Punctuation` `Pc`	`Connector_Punctuation`
`Control` `Cc` `cntrl`	`Control`
`Currency_Symbol` `Sc`	`Currency_Symbol`
`Dash_Punctuation` `Pd`	`Dash_Punctuation`
`Decimal_Number` `Nd` `digit`	`Decimal_Number`
`Enclosing_Mark` `Me`	`Enclosing_Mark`
`Final_Punctuation` `Pf`	`Final_Punctuation`
`Format` `Cf`	`Format`
`Initial_Punctuation` `Pi`	`Initial_Punctuation`
`Letter` `L`	`Letter`
`Letter_Number` `Nl`	`Letter_Number`
`Line_Separator` `Zl`	`Line_Separator`
`Lowercase_Letter` `Ll`	`Lowercase_Letter`
`Mark` `M` `Combining_Mark`	`Mark`
`Math_Symbol` `Sm`	`Math_Symbol`
`Modifier_Letter` `Lm`	`Modifier_Letter`
`Modifier_Symbol` `Sk`	`Modifier_Symbol`
`Nonspacing_Mark` `Mn`	`Nonspacing_Mark`
`Number` `N`	`Number`
`Open_Punctuation` `Ps`	`Open_Punctuation`
`Other` `C`	`Other`
`Other_Letter` `Lo`	`Other_Letter`
`Other_Number` `No`	`Other_Number`
`Other_Punctuation` `Po`	`Other_Punctuation`
`Other_Symbol` `So`	`Other_Symbol`
`Paragraph_Separator` `Zp`	`Paragraph_Separator`
`Private_Use` `Co`	`Private_Use`
`Punctuation` `P` `punct`	`Punctuation`
`Separator` `Z`	`Separator`
`Space_Separator` `Zs`	`Space_Separator`
`Spacing_Mark` `Mc`	`Spacing_Mark`
`Surrogate` `Cs`	`Surrogate`
`Symbol` `S`	`Symbol`
`Titlecase_Letter` `Lt`	`Titlecase_Letter`
`Unassigned` `Cn`	`Unassigned`
`Uppercase_Letter` `Lu`	`Uppercase_Letter`

Table 54: Value aliases and canonical values for the Unicode properties Script and Script_Extensions

Property value and aliases	Canonical property value
`Adlam` `Adlm`	`Adlam`
`Ahom` `Ahom`	`Ahom`
`Anatolian_Hieroglyphs` `Hluw`	`Anatolian_Hieroglyphs`
`Arabic` `Arab`	`Arabic`
`Armenian` `Armn`	`Armenian`
`Avestan` `Avst`	`Avestan`
`Balinese` `Bali`	`Balinese`
`Bamum` `Bamu`	`Bamum`
`Bassa_Vah` `Bass`	`Bassa_Vah`
`Batak` `Batk`	`Batak`
`Bengali` `Beng`	`Bengali`
`Bhaiksuki` `Bhks`	`Bhaiksuki`
`Bopomofo` `Bopo`	`Bopomofo`
`Brahmi` `Brah`	`Brahmi`
`Braille` `Brai`	`Braille`
`Buginese` `Bugi`	`Buginese`
`Buhid` `Buhd`	`Buhid`
`Canadian_Aboriginal` `Cans`	`Canadian_Aboriginal`
`Carian` `Cari`	`Carian`
`Caucasian_Albanian` `Aghb`	`Caucasian_Albanian`
`Chakma` `Cakm`	`Chakma`
`Cham` `Cham`	`Cham`
`Cherokee` `Cher`	`Cherokee`
`Common` `Zyyy`	`Common`
`Coptic` `Copt` `Qaac`	`Coptic`
`Cuneiform` `Xsux`	`Cuneiform`
`Cypriot` `Cprt`	`Cypriot`
`Cyrillic` `Cyrl`	`Cyrillic`
`Deseret` `Dsrt`	`Deseret`
`Devanagari` `Deva`	`Devanagari`
`Duployan` `Dupl`	`Duployan`
`Egyptian_Hieroglyphs` `Egyp`	`Egyptian_Hieroglyphs`
`Elbasan` `Elba`	`Elbasan`
`Ethiopic` `Ethi`	`Ethiopic`
`Georgian` `Geor`	`Georgian`
`Glagolitic` `Glag`	`Glagolitic`
`Gothic` `Goth`	`Gothic`
`Grantha` `Gran`	`Grantha`
`Greek` `Grek`	`Greek`
`Gujarati` `Gujr`	`Gujarati`
`Gurmukhi` `Guru`	`Gurmukhi`
`Han` `Hani`	`Han`
`Hangul` `Hang`	`Hangul`
`Hanunoo` `Hano`	`Hanunoo`
`Hatran` `Hatr`	`Hatran`
`Hebrew` `Hebr`	`Hebrew`
`Hiragana` `Hira`	`Hiragana`
`Imperial_Aramaic` `Armi`	`Imperial_Aramaic`
`Inherited` `Zinh` `Qaai`	`Inherited`
`Inscriptional_Pahlavi` `Phli`	`Inscriptional_Pahlavi`
`Inscriptional_Parthian` `Prti`	`Inscriptional_Parthian`
`Javanese` `Java`	`Javanese`
`Kaithi` `Kthi`	`Kaithi`
`Kannada` `Knda`	`Kannada`
`Katakana` `Kana`	`Katakana`
`Kayah_Li` `Kali`	`Kayah_Li`
`Kharoshthi` `Khar`	`Kharoshthi`
`Khmer` `Khmr`	`Khmer`
`Khojki` `Khoj`	`Khojki`
`Khudawadi` `Sind`	`Khudawadi`
`Lao` `Laoo`	`Lao`
`Latin` `Latn`	`Latin`
`Lepcha` `Lepc`	`Lepcha`
`Limbu` `Limb`	`Limbu`
`Linear_A` `Lina`	`Linear_A`
`Linear_B` `Linb`	`Linear_B`
`Lisu` `Lisu`	`Lisu`
`Lycian` `Lyci`	`Lycian`
`Lydian` `Lydi`	`Lydian`
`Mahajani` `Mahj`	`Mahajani`
`Malayalam` `Mlym`	`Malayalam`
`Mandaic` `Mand`	`Mandaic`
`Manichaean` `Mani`	`Manichaean`
`Marchen` `Marc`	`Marchen`
`Masaram_Gondi` `Gonm`	`Masaram_Gondi`
`Meetei_Mayek` `Mtei`	`Meetei_Mayek`
`Mende_Kikakui` `Mend`	`Mende_Kikakui`
`Meroitic_Cursive` `Merc`	`Meroitic_Cursive`
`Meroitic_Hieroglyphs` `Mero`	`Meroitic_Hieroglyphs`
`Miao` `Plrd`	`Miao`
`Modi` `Modi`	`Modi`
`Mongolian` `Mong`	`Mongolian`
`Mro` `Mroo`	`Mro`
`Multani` `Mult`	`Multani`
`Myanmar` `Mymr`	`Myanmar`
`Nabataean` `Nbat`	`Nabataean`
`New_Tai_Lue` `Talu`	`New_Tai_Lue`
`Newa` `Newa`	`Newa`
`Nko` `Nkoo`	`Nko`
`Nushu` `Nshu`	`Nushu`
`Ogham` `Ogam`	`Ogham`
`Ol_Chiki` `Olck`	`Ol_Chiki`
`Old_Hungarian` `Hung`	`Old_Hungarian`
`Old_Italic` `Ital`	`Old_Italic`
`Old_North_Arabian` `Narb`	`Old_North_Arabian`
`Old_Permic` `Perm`	`Old_Permic`
`Old_Persian` `Xpeo`	`Old_Persian`
`Old_South_Arabian` `Sarb`	`Old_South_Arabian`
`Old_Turkic` `Orkh`	`Old_Turkic`
`Oriya` `Orya`	`Oriya`
`Osage` `Osge`	`Osage`
`Osmanya` `Osma`	`Osmanya`
`Pahawh_Hmong` `Hmng`	`Pahawh_Hmong`
`Palmyrene` `Palm`	`Palmyrene`
`Pau_Cin_Hau` `Pauc`	`Pau_Cin_Hau`
`Phags_Pa` `Phag`	`Phags_Pa`
`Phoenician` `Phnx`	`Phoenician`
`Psalter_Pahlavi` `Phlp`	`Psalter_Pahlavi`
`Rejang` `Rjng`	`Rejang`
`Runic` `Runr`	`Runic`
`Samaritan` `Samr`	`Samaritan`
`Saurashtra` `Saur`	`Saurashtra`
`Sharada` `Shrd`	`Sharada`
`Shavian` `Shaw`	`Shavian`
`Siddham` `Sidd`	`Siddham`
`SignWriting` `Sgnw`	`SignWriting`
`Sinhala` `Sinh`	`Sinhala`
`Sora_Sompeng` `Sora`	`Sora_Sompeng`
`Soyombo` `Soyo`	`Soyombo`
`Sundanese` `Sund`	`Sundanese`
`Syloti_Nagri` `Sylo`	`Syloti_Nagri`
`Syriac` `Syrc`	`Syriac`
`Tagalog` `Tglg`	`Tagalog`
`Tagbanwa` `Tagb`	`Tagbanwa`
`Tai_Le` `Tale`	`Tai_Le`
`Tai_Tham` `Lana`	`Tai_Tham`
`Tai_Viet` `Tavt`	`Tai_Viet`
`Takri` `Takr`	`Takri`
`Tamil` `Taml`	`Tamil`
`Tangut` `Tang`	`Tangut`
`Telugu` `Telu`	`Telugu`
`Thaana` `Thaa`	`Thaana`
`Thai` `Thai`	`Thai`
`Tibetan` `Tibt`	`Tibetan`
`Tifinagh` `Tfng`	`Tifinagh`
`Tirhuta` `Tirh`	`Tirhuta`
`Ugaritic` `Ugar`	`Ugaritic`
`Vai` `Vaii`	`Vai`
`Warang_Citi` `Wara`	`Warang_Citi`
`Yi` `Yiii`	`Yi`
`Zanabazar_Square` `Zanb`	`Zanabazar_Square`

21.2.2.9AtomEscape

With parameter direction.

The production AtomEscape::DecimalEscape evaluates as follows:

Evaluate DecimalEscape to obtain an integer n.
Assert: n ≤ NcapturingParens.
Call BackreferenceMatcher(n, direction) and return its Matcher result.

The production AtomEscape::CharacterEscape evaluates as follows:

Evaluate CharacterEscape to obtain a character ch.
Let A be a one-element CharSet containing the character ch.
Call CharacterSetMatcher(A, false, direction) and return its Matcher result.

The production AtomEscape::CharacterClassEscape evaluates as follows:

Evaluate CharacterClassEscape to obtain a CharSet A.
Call CharacterSetMatcher(A, false, direction) and return its Matcher result.

Note

An escape sequence of the form \ followed by a nonzero decimal number n matches the result of the nth set of capturing parentheses (21.2.2.1). It is an error if the 正则表达式 has fewer than n capturing parentheses. If the 正则表达式 has n or more capturing parentheses but the nth one is undefined because it has not captured anything, then the backreference always succeeds.

The production AtomEscape::kGroupName evaluates as follows:

Search the enclosing Pattern for an instance of a GroupSpecifier for a RegExpIdentifierName which has a 字符值 equal to the 字符值 of the RegExpIdentifierName contained in GroupName.
Assert: A unique such GroupSpecifier is found.
Let parenIndex be the number of left-capturing parentheses in the entire 正则表达式 that occur to the left of the located GroupSpecifier. This is the total number of Atom::(GroupSpecifierDisjunction) 解析节点 prior to or enclosing the located GroupSpecifier.
Call BackreferenceMatcher(parenIndex, direction) and return its Matcher result.

21.2.2.9.1运行时语义: BackreferenceMatcher ( `n`, `direction` )

The 抽象操作 BackreferenceMatcher takes two arguments, an integer n and an integer direction, and 执行如下:

Return an internal Matcher closure that takes two arguments, a State x and a Continuation c, and 执行如下:
1. Let cap be x's captures List.
2. Let s be cap[n].
3. If s is undefined, return c(x).
4. Let e be x's endIndex.
5. Let len be the number of elements in s.
6. Let f be e + direction × len.
7. If f < 0 or f > InputLength, return failure.
8. Let g be min(e, f).
9. If there exists an integer i between 0 (inclusive) and len (exclusive) such that Canonicalize(s[i]) is not the same character value as Canonicalize(Input[g + i]), return failure.
10. Let y be the State (f, cap).
11. Call c(y) and return its result.

21.2.2.10CharacterEscape

The CharacterEscape productions evaluate as follows:

ControlEscape

[lookahead ∉ DecimalDigit]

Let cv be the 字符值 of this CharacterEscape.
Return the character whose character value is cv.

21.2.2.11DecimalEscape

The DecimalEscape productions evaluate as follows:

opt

Return the 捕获分组号 of this DecimalEscape.

Note

If \ is followed by a decimal number n whose first digit is not 0, then the escape sequence is considered to be a backreference. It is an error if n is greater than the total number of left-capturing parentheses in the entire 正则表达式.

21.2.2.12CharacterClassEscape

The production CharacterClassEscape::d evaluates as follows:

Return the ten-element set of characters containing the characters 0 through 9 inclusive.

The production CharacterClassEscape::D evaluates as follows:

Return the set of all characters not included in the set returned by CharacterClassEscape::d .

The production CharacterClassEscape::s evaluates as follows:

Return the set of characters containing the characters that are on the right-hand side of the WhiteSpace or LineTerminator productions.

The production CharacterClassEscape::S evaluates as follows:

Return the set of all characters not included in the set returned by CharacterClassEscape::s .

The production CharacterClassEscape::w evaluates as follows:

Return the set of all characters returned by WordCharacters().

The production CharacterClassEscape::W evaluates as follows:

Return the set of all characters not included in the set returned by CharacterClassEscape::w .

The production CharacterClassEscape::p{UnicodePropertyValueExpression} evaluates by returning the CharSet containing all Unicode code points included in the CharSet returned by UnicodePropertyValueExpression.

The production CharacterClassEscape::P{UnicodePropertyValueExpression} evaluates by returning the CharSet containing all Unicode code points not included in the CharSet returned by UnicodePropertyValueExpression.

The production UnicodePropertyValueExpression::UnicodePropertyName=UnicodePropertyValue evaluates as follows:

Let ps be 源文本 of UnicodePropertyName.
Let p be ! UnicodeMatchProperty(ps).
Assert: p is a Unicode 属性名 or property alias listed in the “属性名 and aliases” column of Table 51.
Let vs be 源文本 of UnicodePropertyValue.
Let v be ! UnicodeMatchPropertyValue(p, vs).
Return the CharSet containing all Unicode code points whose character database definition includes the property p with value v.

The production UnicodePropertyValueExpression::LoneUnicodePropertyNameOrValue evaluates as follows:

Let s be 源文本 of LoneUnicodePropertyNameOrValue.
If ! UnicodeMatchPropertyValue("General_Category", s) is identical to a List of Unicode code points that is the name of a Unicode general category or general category alias listed in the “Property value and aliases” column of Table 53, then
1. Return the CharSet containing all Unicode code points whose character database definition includes the property “General_Category” with value s.
Let p be ! UnicodeMatchProperty(s).
Assert: p is a binary Unicode property or binary property alias listed in the “属性名 and aliases” column of Table 52.
Return the CharSet containing all Unicode code points whose character database definition includes the property p with value “True”.

21.2.2.13CharacterClass

The production CharacterClass::[ClassRanges] evaluates as follows:

Evaluate ClassRanges to obtain a CharSet A.
Return the two results A and false.

The production CharacterClass::[^ClassRanges] evaluates as follows:

Evaluate ClassRanges to obtain a CharSet A.
Return the two results A and true.

21.2.2.14ClassRanges

The production ClassRanges::[empty] evaluates as follows:

Return the empty CharSet.

The production ClassRanges::NonemptyClassRanges evaluates as follows:

Return the CharSet that is the result of evaluating NonemptyClassRanges.

21.2.2.15NonemptyClassRanges

The production NonemptyClassRanges::ClassAtom evaluates as follows:

Return the CharSet that is the result of evaluating ClassAtom.

The production NonemptyClassRanges::ClassAtomNonemptyClassRangesNoDash evaluates as follows:

Evaluate ClassAtom to obtain a CharSet A.
Evaluate NonemptyClassRangesNoDash to obtain a CharSet B.
Return the union of CharSets A and B.

The production NonemptyClassRanges::ClassAtom-ClassAtomClassRanges evaluates as follows:

Evaluate the first ClassAtom to obtain a CharSet A.
Evaluate the second ClassAtom to obtain a CharSet B.
Evaluate ClassRanges to obtain a CharSet C.
Call CharacterRange(A, B) and let D be the resulting CharSet.
Return the union of CharSets D and C.

21.2.2.15.1运行时语义: CharacterRange ( `A`, `B` )

The 抽象操作 CharacterRange takes two CharSet parameters A and B and 执行如下:

Assert: A and B each contain exactly one character.
Let a be the one character in CharSet A.
Let b be the one character in CharSet B.
Let i be the character value of character a.
Let j be the character value of character b.
Assert: i ≤ j.
Return the set containing all characters numbered i through j, inclusive.

21.2.2.16NonemptyClassRangesNoDash

The production NonemptyClassRangesNoDash::ClassAtom evaluates as follows:

Return the CharSet that is the result of evaluating ClassAtom.

The production NonemptyClassRangesNoDash::ClassAtomNoDashNonemptyClassRangesNoDash evaluates as follows:

Evaluate ClassAtomNoDash to obtain a CharSet A.
Evaluate NonemptyClassRangesNoDash to obtain a CharSet B.
Return the union of CharSets A and B.

The production NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates as follows:

Evaluate ClassAtomNoDash to obtain a CharSet A.
Evaluate ClassAtom to obtain a CharSet B.
Evaluate ClassRanges to obtain a CharSet C.
Call CharacterRange(A, B) and let D be the resulting CharSet.
Return the union of CharSets D and C.

Note 1

ClassRanges can expand into a single ClassAtom and/or ranges of two ClassAtom separated by dashes. In the latter case the ClassRanges includes all characters between the first ClassAtom and the second ClassAtom, inclusive; an error occurs if either ClassAtom does not represent a single character (例如, if one is \w) or if the first ClassAtom's character value is greater than the second ClassAtom's character value.

Note 2

Even if the pattern ignores case, the case of the two ends of a range is significant in determining which characters belong to the range. Thus, 例如, the pattern /[E-F]/i matches only the letters E, F, e, and f, while the pattern /[E-f]/i matches all upper and lower-case letters in the Unicode Basic Latin block as well as the symbols [, \, ], ^, _, and `.

Note 3

A - character can be treated literally or it can denote a range. It is treated literally if it is the first or last character of ClassRanges, the beginning or end limit of a range specification, or immediately follows a range specification.

21.2.2.17ClassAtom

The production ClassAtom::- evaluates as follows:

Return the CharSet containing the single character - U+002D (HYPHEN-MINUS).

The production ClassAtom::ClassAtomNoDash evaluates as follows:

Return the CharSet that is the result of evaluating ClassAtomNoDash.

21.2.2.18ClassAtomNoDash

The production ClassAtomNoDash::SourceCharacterbut not one of \ or ] or - evaluates as follows:

Return the CharSet containing the character matched by SourceCharacter.

The production ClassAtomNoDash::\ClassEscape evaluates as follows:

Return the CharSet that is the result of evaluating ClassEscape.

21.2.2.19ClassEscape

The ClassEscape productions evaluate as follows:

Let cv be the 字符值 of this ClassEscape.
Let c be the character whose character value is cv.
Return the CharSet containing the single character c.

Return the CharSet that is the result of evaluating CharacterClassEscape.

Note

A ClassAtom can use any of the escape sequences that are allowed in the rest of the 正则表达式 except for \b, \B, and backreferences. Inside a CharacterClass, \b means the backspace character, while \B and backreferences raise errors. Using a backreference inside a ClassAtom causes an error.

21.2.3RegExp 构造器

The RegExp 构造器 is the %RegExp% 内部对象 and the 初始值 of the RegExp property of the 全局对象. When RegExp 被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 RegExp 对象. Thus the function call RegExp(…) is equivalent to the object creation expression new RegExp(…) with the same arguments.

The RegExp 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 RegExp behaviour must include a super call to the RegExp 构造器 to create and initialize subclass instances with the necessary 内部属性.

21.2.3.1RegExp ( `pattern`, `flags` )

执行如下:

Let patternIsRegExp be ? IsRegExp(pattern).
If NewTarget is undefined, then
1. Let newTarget be the active 函数对象.
2. If patternIsRegExp is true and flags is undefined, then
  1. Let patternConstructor be ? Get(pattern, "构造器").
  2. If SameValue(newTarget, patternConstructor) is true, return pattern.
Else, let newTarget be NewTarget.
If Type(pattern) is Object and pattern has a [[RegExpMatcher]] 内部属性, then
1. Let P be pattern.[[OriginalSource]].
2. If flags is undefined, let F be pattern.[[OriginalFlags]].
3. Else, let F be flags.
Else if patternIsRegExp is true, then
1. Let P be ? Get(pattern, "source").
2. If flags is undefined, then
  1. Let F be ? Get(pattern, "flags").
3. Else, let F be flags.
Else,
1. Let P be pattern.
2. Let F be flags.
Let O be ? RegExpAlloc(newTarget).
Return ? RegExpInitialize(O, P, F).

Note

If pattern is supplied using a StringLiteral, the usual escape sequence substitutions are performed before the String is processed by RegExp. If pattern must contain an escape sequence to be recognized by RegExp, any U+005C (REVERSE SOLIDUS) code points must be escaped within the StringLiteral to prevent them being removed when the contents of the StringLiteral are formed.

21.2.3.2RegExp 构造器的抽象操作

21.2.3.2.1运行时语义: RegExpAlloc ( `newTarget` )

When the 抽象操作 RegExpAlloc with argument newTarget is called, 执行如下:

Let obj be ? OrdinaryCreateFromConstructor(newTarget, "%RegExpPrototype%", « [[RegExpMatcher]], [[OriginalSource]], [[OriginalFlags]] »).
Perform ! DefinePropertyOrThrow(obj, "lastIndex", PropertyDescriptor {[[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
Return obj.

21.2.3.2.2运行时语义: RegExpInitialize ( `obj`, `pattern`, `flags` )

When the 抽象操作 RegExpInitialize with arguments obj, pattern, and flags is called, 执行如下:

If pattern is undefined, let P be the empty String.
Else, let P be ? ToString(pattern).
If flags is undefined, let F be the empty String.
Else, let F be ? ToString(flags).
If F contains any 代码单元 other than "g", "i", "m", "s", "u", or "y" or if it contains the same 代码单元 more than once, 抛出一个 SyntaxError 异常.
If F contains "u", let BMP be false; else let BMP be true.
If BMP is true, then
1. Parse P using the grammars in 21.2.1 and interpreting each of its 16-bit elements as a Unicode BMP 码点. UTF-16 decoding is not applied to the elements. The 目标符 for the parse is Pattern[~U, ~N]. If the result of parsing contains a GroupName, reparse with the 目标符 Pattern[~U, +N] and use this result instead. 抛出一个 SyntaxError 异常 if P did not conform to the grammar, if any elements of P were not matched by the parse, or if any 早期错误 conditions exist.
2. Let patternCharacters be a List whose elements are the 代码单元 elements of P.
Else,
1. Parse P using the grammars in 21.2.1 and interpreting P as UTF-16 encoded Unicode code points (6.1.4). The 目标符 for the parse is Pattern[+U, +N]. 抛出一个 SyntaxError 异常 if P did not conform to the grammar, if any elements of P were not matched by the parse, or if any 早期错误 conditions exist.
2. Let patternCharacters be a List whose elements are the code points resulting from applying UTF-16 decoding to P's sequence of elements.
Set obj.[[OriginalSource]] to P.
Set obj.[[OriginalFlags]] to F.
Set obj.[[RegExpMatcher]] to the internal procedure that evaluates the above parse of P by applying the 语义 provided in 21.2.2 using patternCharacters as the pattern's List of SourceCharacter values and F as the flag parameters.
Perform ? Set(obj, "lastIndex", 0, true).
Return obj.

21.2.3.2.3运行时语义: RegExpCreate ( `P`, `F` )

When the 抽象操作 RegExpCreate with arguments P and F is called, 执行如下:

Let obj be ? RegExpAlloc(%RegExp%).
Return ? RegExpInitialize(obj, P, F).

21.2.3.2.4运行时语义: EscapeRegExpPattern ( `P`, `F` )

When the 抽象操作 EscapeRegExpPattern with arguments P and F is called, the following occurs:

Let S be a String in the form of a Pattern[~U] (Pattern[+U] if F contains "u") equivalent to P interpreted as UTF-16 encoded Unicode code points (6.1.4), in which certain code points are escaped as described below. S may or may not be identical to P; however, the internal procedure that would result from evaluating S as a Pattern[~U] (Pattern[+U] if F contains "u") must behave identically to the internal procedure given by the constructed object's [[RegExpMatcher]] 内部属性. Multiple calls to this 抽象操作 using the same values for P and F must produce identical results.
The code points / or any LineTerminator occurring in the pattern shall be escaped in S as necessary to ensure that the string-concatenation of "/", S, "/", and F can be parsed (in an appropriate lexical context) as a RegularExpressionLiteral that behaves identically to the constructed 正则表达式. 例如, if P is "/", then S could be "\/" or "\u002F", among other possibilities, but not "/", because /// followed by F would be parsed as a SingleLineComment rather than a RegularExpressionLiteral. If P is the empty String, this specification can be met by letting S be "(?:)".
Return S.

21.2.4RegExp 构造器的属性

[[Prototype]] 内部属性的值 of the RegExp 构造器 is the 内部对象 %FunctionPrototype%.

The RegExp 构造器有以下属性:

21.2.4.1RegExp.prototype

The 初始值 of RegExp.prototype is the 内部对象 %RegExpPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

21.2.4.2get RegExp [ @@species ]

RegExp[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

RegExp prototype methods normally use their this object's 构造器 to create a derived object. However, a subclass 构造器 may over-ride that default behaviour by redefining its @@species property.

21.2.5RegExp 原型对象的属性

The RegExp 原型对象 is the 内部对象 %RegExpPrototype%. The RegExp 原型对象 is an 普通对象. It is not a RegExp instance and does not have a [[RegExpMatcher]] 内部属性 or any of the other 内部属性 of RegExp instance objects.

[[Prototype]] 内部属性的值 of the RegExp 原型对象 is the 内部对象 %ObjectPrototype%.

Note

The RegExp 原型对象 does not have a valueOf property of its own; however, it inherits the valueOf property from the Object 原型对象.

21.2.5.1RegExp.prototype.constructor

The 初始值 of RegExp.prototype.constructor is the 内部对象 %RegExp%.

21.2.5.2RegExp.prototype.exec ( `string` )

Performs a 正则表达式 match of string against the 正则表达式 and returns an Array object containing the results of the match, or null if string did not match.

The String ToString(string) is searched for an occurrence of the 正则表达式 pattern as follows:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have a [[RegExpMatcher]] 内部属性, 抛出一个 TypeError 异常.
Let S be ? ToString(string).
Return ? RegExpBuiltinExec(R, S).

21.2.5.2.1运行时语义: RegExpExec ( `R`, `S` )

The 抽象操作 RegExpExec with arguments R and S 执行如下:

Assert: Type(R) is Object.
Assert: Type(S) is String.
Let exec be ? Get(R, "exec").
If IsCallable(exec) is true, then
1. Let result be ? Call(exec, R, « S »).
2. If Type(result) is neither Object or Null, 抛出一个 TypeError 异常.
3. Return result.
If R does not have a [[RegExpMatcher]] 内部属性, 抛出一个 TypeError 异常.
Return ? RegExpBuiltinExec(R, S).

Note

If a callable exec property is not found this 算法 falls back to attempting to use the 内置 RegExp matching 算法. This provides compatible behaviour for code written for prior editions where most 内置算法 that use 正则表达式 did not perform a dynamic property lookup of exec.

21.2.5.2.2运行时语义: RegExpBuiltinExec ( `R`, `S` )

The 抽象操作 RegExpBuiltinExec with arguments R and S 执行如下:

Assert: R is an initialized RegExp instance.
Assert: Type(S) is String.
Let length be the number of 代码单元 in S.
Let lastIndex be ? ToLength(? Get(R, "lastIndex")).
Let flags be R.[[OriginalFlags]].
If flags contains "g", let global be true, else let global be false.
If flags contains "y", let sticky be true, else let sticky be false.
If global is false and sticky is false, set lastIndex to 0.
Let matcher be R.[[RegExpMatcher]].
If flags contains "u", let fullUnicode be true, else let fullUnicode be false.
Let matchSucceeded be false.
Repeat, while matchSucceeded is false
1. If lastIndex > length, then
  1. If global is true or sticky is true, then
    1. Perform ? Set(R, "lastIndex", 0, true).
  2. Return null.
2. Let r be matcher(S, lastIndex).
3. If r is failure, then
  1. If sticky is true, then
    1. Perform ? Set(R, "lastIndex", 0, true).
    2. Return null.
  2. Set lastIndex to AdvanceStringIndex(S, lastIndex, fullUnicode).
4. Else,
  1. Assert: r is a State.
  2. Set matchSucceeded to true.
Let e be r's endIndex value.
If fullUnicode is true, then
1. e is an index into the Input character list, derived from S, matched by matcher. Let eUTF be the smallest index into S that corresponds to the character at element e of Input. If e is greater than or equal to the number of elements in Input, then eUTF is the number of 代码单元 in S.
2. Set e to eUTF.
If global is true or sticky is true, then
1. Perform ? Set(R, "lastIndex", e, true).
Let n be the number of elements in r's captures List. (This is the same value as 21.2.2.1's NcapturingParens.)
Assert: n < 2³²-1.
Let A be ! ArrayCreate(n + 1).
Assert: The value of A's "length" property is n + 1.
Perform ! CreateDataProperty(A, "index", lastIndex).
Perform ! CreateDataProperty(A, "input", S).
Let matchedSubstr be the matched substring (i.e. the portion of S between offset lastIndex inclusive and offset e exclusive).
Perform ! CreateDataProperty(A, "0", matchedSubstr).
If R contains any GroupName, then
1. Let groups be ObjectCreate(null).
Else,
1. Let groups be undefined.
Perform ! CreateDataProperty(A, "groups", groups).
For each integer i such that i > 0 and i ≤ n, do
1. Let captureI be i^th element of r's captures List.
2. If captureI is undefined, let capturedValue be undefined.
3. Else if fullUnicode is true, then
  1. Assert: captureI is a List of code points.
  2. Let capturedValue be the String 值 whose 代码单元 are the UTF16Encoding of the code points of captureI.
4. Else fullUnicode is false,
  1. Assert: captureI is a List of 代码单元.
  2. Let capturedValue be the String 值 consisting of the 代码单元 of captureI.
5. Perform ! CreateDataProperty(A, ! ToString(i), capturedValue).
6. If the ith capture of R was defined with a GroupName, then
  1. Let s be the 字符值 of the corresponding RegExpIdentifierName.
  2. Perform ! CreateDataProperty(groups, s, capturedValue).
Return A.

21.2.5.2.3AdvanceStringIndex ( `S`, `index`, `unicode` )

The 抽象操作 AdvanceStringIndex with arguments S, index, and unicode 执行如下:

Assert: Type(S) is String.
Assert: index is an integer such that 0≤index≤2⁵³-1.
Assert: Type(unicode) is Boolean.
If unicode is false, return index+1.
Let length be the number of 代码单元 in S.
If index+1 ≥ length, return index+1.
Let first be the 数字值 of the 代码单元 at index index within S.
If first < 0xD800 or first > 0xDBFF, return index+1.
Let second be the 数字值 of the 代码单元 at index index+1 within S.
If second < 0xDC00 or second > 0xDFFF, return index+1.
Return index+2.

21.2.5.3get RegExp.prototype.dotAll

RegExp.prototype.dotAll is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x0073 (LATIN SMALL LETTER S), return true.
Return false.

21.2.5.4get RegExp.prototype.flags

RegExp.prototype.flags is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
Let result be the empty String.
Let global be ToBoolean(? Get(R, "global")).
If global is true, append the 代码单元 0x0067 (LATIN SMALL LETTER G) as the last 代码单元 of result.
Let ignoreCase be ToBoolean(? Get(R, "ignoreCase")).
If ignoreCase is true, append the 代码单元 0x0069 (LATIN SMALL LETTER I) as the last 代码单元 of result.
Let multiline be ToBoolean(? Get(R, "multiline")).
If multiline is true, append the 代码单元 0x006D (LATIN SMALL LETTER M) as the last 代码单元 of result.
Let dotAll be ToBoolean(? Get(R, "dotAll")).
If dotAll is true, append the 代码单元 0x0073 (LATIN SMALL LETTER S) as the last 代码单元 of result.
Let unicode be ToBoolean(? Get(R, "unicode")).
If unicode is true, append the 代码单元 0x0075 (LATIN SMALL LETTER U) as the last 代码单元 of result.
Let sticky be ToBoolean(? Get(R, "sticky")).
If sticky is true, append the 代码单元 0x0079 (LATIN SMALL LETTER Y) as the last 代码单元 of result.
Return result.

21.2.5.5get RegExp.prototype.global

RegExp.prototype.global is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x0067 (LATIN SMALL LETTER G), return true.
Return false.

21.2.5.6get RegExp.prototype.ignoreCase

RegExp.prototype.ignoreCase is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x0069 (LATIN SMALL LETTER I), return true.
Return false.

21.2.5.7RegExp.prototype [ @@match ] ( `string` )

When the @@match method is called with argument string, 执行如下:

Let rx be the this value.
If Type(rx) is not Object, 抛出一个 TypeError 异常.
Let S be ? ToString(string).
Let global be ToBoolean(? Get(rx, "global")).
If global is false, then
1. Return ? RegExpExec(rx, S).
Else global is true,
1. Let fullUnicode be ToBoolean(? Get(rx, "unicode")).
2. Perform ? Set(rx, "lastIndex", 0, true).
3. Let A be ! ArrayCreate(0).
4. Let n be 0.
5. Repeat,
  1. Let result be ? RegExpExec(rx, S).
  2. If result is null, then
    1. If n=0, return null.
    2. Return A.
  3. Else result is not null,
    1. Let matchStr be ? ToString(? Get(result, "0")).
    2. Let status be CreateDataProperty(A, ! ToString(n), matchStr).
    3. Assert: status is true.
    4. If matchStr is the empty String, then
      1. Let thisIndex be ? ToLength(? Get(rx, "lastIndex")).
      2. Let nextIndex be AdvanceStringIndex(S, thisIndex, fullUnicode).
      3. Perform ? Set(rx, "lastIndex", nextIndex, true).
    5. Increment n.

The value of the name property of this function is "[Symbol.match]".

Note

The @@match property is used by the IsRegExp 抽象操作 to identify objects that have the basic behaviour of 正则表达式. The absence of a @@match property or the existence of such a property whose value does not Boolean coerce to true indicates that the object is not intended to be used as a 正则表达式 object.

21.2.5.8get RegExp.prototype.multiline

RegExp.prototype.multiline is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x006D (LATIN SMALL LETTER M), return true.
Return false.

21.2.5.9RegExp.prototype [ @@replace ] ( `string`, `replaceValue` )

When the @@replace method is called with arguments string and replaceValue, 执行如下:

Let rx be the this value.
If Type(rx) is not Object, 抛出一个 TypeError 异常.
Let S be ? ToString(string).
Let lengthS be the number of 代码单元 elements in S.
Let functionalReplace be IsCallable(replaceValue).
If functionalReplace is false, then
1. Let replaceValue be ? ToString(replaceValue).
Let global be ToBoolean(? Get(rx, "global")).
If global is true, then
1. Let fullUnicode be ToBoolean(? Get(rx, "unicode")).
2. Perform ? Set(rx, "lastIndex", 0, true).
Let results be a new empty List.
Let done be false.
Repeat, while done is false
1. Let result be ? RegExpExec(rx, S).
2. If result is null, set done to true.
3. Else result is not null,
  1. Append result to the end of results.
  2. If global is false, set done to true.
  3. Else,
    1. Let matchStr be ? ToString(? Get(result, "0")).
    2. If matchStr is the empty String, then
      1. Let thisIndex be ? ToLength(? Get(rx, "lastIndex")).
      2. Let nextIndex be AdvanceStringIndex(S, thisIndex, fullUnicode).
      3. Perform ? Set(rx, "lastIndex", nextIndex, true).
Let accumulatedResult be the empty String 值.
Let nextSourcePosition be 0.
For each result in results, do
1. Let nCaptures be ? ToLength(? Get(result, "length")).
2. Let nCaptures be max(nCaptures - 1, 0).
3. Let matched be ? ToString(? Get(result, "0")).
4. Let matchLength be the number of 代码单元 in matched.
5. Let position be ? ToInteger(? Get(result, "index")).
6. Let position be max(min(position, lengthS), 0).
7. Let n be 1.
8. Let captures be a new empty List.
9. Repeat, while n ≤ nCaptures
  1. Let capN be ? Get(result, ! ToString(n)).
  2. If capN is not undefined, then
    1. Let capN be ? ToString(capN).
  3. Append capN as the last element of captures.
  4. Let n be n+1.
10. Let namedCaptures be ? Get(result, "groups").
11. If functionalReplace is true, then
  1. Let replacerArgs be « matched ».
  2. Append in list order the elements of captures to the end of the List replacerArgs.
  3. Append position and S to replacerArgs.
  4. If namedCaptures is not undefined, then
    1. Append namedCaptures as the last element of replacerArgs.
  5. Let replValue be ? Call(replaceValue, undefined, replacerArgs).
  6. Let replacement be ? ToString(replValue).
12. Else,
  1. Let replacement be GetSubstitution(matched, S, position, captures, namedCaptures, replaceValue).
13. If position ≥ nextSourcePosition, then
  1. NOTE: position should not normally move backwards. If it does, it is an indication of an ill-behaving RegExp subclass or use of an access triggered side-effect to change the global flag or other characteristics of rx. In such cases, the corresponding substitution is ignored.
  2. Let accumulatedResult be the string-concatenation of the current value of accumulatedResult, the substring of S consisting of the 代码单元 from nextSourcePosition (inclusive) up to position (exclusive), and replacement.
  3. Let nextSourcePosition be position + matchLength.
If nextSourcePosition ≥ lengthS, return accumulatedResult.
Return the string-concatenation of accumulatedResult and the substring of S consisting of the 代码单元 from nextSourcePosition (inclusive) up through the final 代码单元 of S (inclusive).

The value of the name property of this function is "[Symbol.replace]".

21.2.5.10RegExp.prototype [ @@search ] ( `string` )

When the @@search method is called with argument string, 执行如下:

Let rx be the this value.
If Type(rx) is not Object, 抛出一个 TypeError 异常.
Let S be ? ToString(string).
Let previousLastIndex be ? Get(rx, "lastIndex").
If SameValue(previousLastIndex, 0) is false, then
1. Perform ? Set(rx, "lastIndex", 0, true).
Let result be ? RegExpExec(rx, S).
Let currentLastIndex be ? Get(rx, "lastIndex").
If SameValue(currentLastIndex, previousLastIndex) is false, then
1. Perform ? Set(rx, "lastIndex", previousLastIndex, true).
If result is null, return -1.
Return ? Get(result, "index").

The value of the name property of this function is "[Symbol.search]".

Note

The lastIndex and global properties of this RegExp 对象 are ignored when performing the search. The lastIndex property is left unchanged.

21.2.5.11get RegExp.prototype.source

RegExp.prototype.source is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalSource]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return "(?:)".
2. Otherwise, 抛出一个 TypeError 异常.
Assert: R has an [[OriginalFlags]] 内部属性.
Let src be R.[[OriginalSource]].
Let flags be R.[[OriginalFlags]].
Return EscapeRegExpPattern(src, flags).

21.2.5.12RegExp.prototype [ @@split ] ( `string`, `limit` )

Note 1

Returns an Array object into which substrings of the result of converting string to a String have been stored. The substrings are determined by searching from left to right for matches of the this value 正则表达式; these occurrences are not part of any substring in the returned array, but serve to divide up the String 值.

The this value may be an empty 正则表达式 or a 正则表达式 that can match an empty String. In this case, the 正则表达式 does not match the empty substring at the beginning or end of the input String, nor does it match the empty substring at the end of the previous separator match. (例如, if the 正则表达式 matches the empty String, the String is split up into individual 代码单元 elements; the length of the result array equals the length of the String, and each substring contains one 代码单元.) Only the first match at a given index of the String is considered, even if backtracking could yield a non-empty-substring match at that index. (例如, /a*?/[Symbol.split]("ab") evaluates to the array ["a","b"], while /a*/[Symbol.split]("ab") evaluates to the array ["","b"].)

If the string is (or converts to) the empty String, the result depends on whether the 正则表达式 can match the empty String. If it can, the result array contains no elements. Otherwise, the result array contains one element, which is the empty String.

If the 正则表达式 contains capturing parentheses, then each time separator is matched the results (including any undefined results) of the capturing parentheses are spliced into the output array. 例如,

/<(\/)?([^<>]+)>/[Symbol.split]("A<B>bold</B>and<CODE>coded</CODE>")

evaluates to the array

["A",undefined,"B","bold","/","B","and",undefined,"CODE","coded","/","CODE",""]

If limit is not undefined, then the output array is truncated so that it contains no more than limit elements.

When the @@split method is called, 执行如下:

Let rx be the this value.
If Type(rx) is not Object, 抛出一个 TypeError 异常.
Let S be ? ToString(string).
Let C be ? SpeciesConstructor(rx, %RegExp%).
Let flags be ? ToString(? Get(rx, "flags")).
If flags contains "u", let unicodeMatching be true.
Else, let unicodeMatching be false.
If flags contains "y", let newFlags be flags.
Else, let newFlags be the string-concatenation of flags and "y".
Let splitter be ? Construct(C, « rx, newFlags »).
Let A be ! ArrayCreate(0).
Let lengthA be 0.
If limit is undefined, let lim be 2³²-1; else let lim be ? ToUint32(limit).
Let size be the length of S.
Let p be 0.
If lim = 0, return A.
If size = 0, then
1. Let z be ? RegExpExec(splitter, S).
2. If z is not null, return A.
3. Perform ! CreateDataProperty(A, "0", S).
4. Return A.
Let q be p.
Repeat, while q < size
1. Perform ? Set(splitter, "lastIndex", q, true).
2. Let z be ? RegExpExec(splitter, S).
3. If z is null, let q be AdvanceStringIndex(S, q, unicodeMatching).
4. Else z is not null,
  1. Let e be ? ToLength(? Get(splitter, "lastIndex")).
  2. Let e be min(e, size).
  3. If e = p, let q be AdvanceStringIndex(S, q, unicodeMatching).
  4. Else e ≠ p,
    1. Let T be the String 值 equal to the substring of S consisting of the elements at indices p (inclusive) through q (exclusive).
    2. Perform ! CreateDataProperty(A, ! ToString(lengthA), T).
    3. Let lengthA be lengthA + 1.
    4. If lengthA = lim, return A.
    5. Let p be e.
    6. Let numberOfCaptures be ? ToLength(? Get(z, "length")).
    7. Let numberOfCaptures be max(numberOfCaptures-1, 0).
    8. Let i be 1.
    9. Repeat, while i ≤ numberOfCaptures,
      1. Let nextCapture be ? Get(z, ! ToString(i)).
      2. Perform ! CreateDataProperty(A, ! ToString(lengthA), nextCapture).
      3. Let i be i + 1.
      4. Let lengthA be lengthA + 1.
      5. If lengthA = lim, return A.
    10. Let q be p.
Let T be the String 值 equal to the substring of S consisting of the elements at indices p (inclusive) through size (exclusive).
Perform ! CreateDataProperty(A, ! ToString(lengthA), T).
Return A.

The value of the name property of this function is "[Symbol.split]".

Note 2

The @@split method ignores the value of the global and sticky properties of this RegExp 对象.

21.2.5.13get RegExp.prototype.sticky

RegExp.prototype.sticky is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x0079 (LATIN SMALL LETTER Y), return true.
Return false.

21.2.5.14RegExp.prototype.test ( `S` )

执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
Let string be ? ToString(S).
Let match be ? RegExpExec(R, string).
If match is not null, return true; else return false.

21.2.5.15RegExp.prototype.toString ( )

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
Let pattern be ? ToString(? Get(R, "source")).
Let flags be ? ToString(? Get(R, "flags")).
Let result be the string-concatenation of "/", pattern, "/", and flags.
Return result.

Note

The returned String has the form of a RegularExpressionLiteral that evaluates to another RegExp 对象 with the same behaviour as this object.

21.2.5.16get RegExp.prototype.unicode

RegExp.prototype.unicode is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let R be the this value.
If Type(R) is not Object, 抛出一个 TypeError 异常.
If R does not have an [[OriginalFlags]] 内部属性, then
1. If SameValue(R, %RegExpPrototype%) is true, return undefined.
2. Otherwise, 抛出一个 TypeError 异常.
Let flags be R.[[OriginalFlags]].
If flags contains the 代码单元 0x0075 (LATIN SMALL LETTER U), return true.
Return false.

21.2.6RegExp 实例的属性

RegExp instances are 普通对象 that 继承属性 from the RegExp 原型对象. RegExp instances have 内部属性 [[RegExpMatcher]], [[OriginalSource]], and [[OriginalFlags]]. The value of the [[RegExpMatcher]] 内部属性 is an 实现-dependent representation of the Pattern of the RegExp 对象.

Note

Prior to ES 2015, RegExp instances were specified as having the own data properties source, global, ignoreCase, and multiline. Those properties are now specified as 访问器属性 of RegExp.prototype.

RegExp instances also have the following property:

21.2.6.1lastIndex

The value of the lastIndex property specifies the String index at which to start the next match. It is coerced to an integer when used (see 21.2.5.2.2). This property shall have the 特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

22索引集合

22.1Array 对象

Array 对象 are 外来对象 that give special treatment to a certain class of property names. See 9.4.2 for a definition of this special treatment.

22.1.1Array 构造器

The Array 构造器 is the %Array% 内部对象 and the 初始值 of the Array property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 Array 外来对象. When Array 被作为一个函数调用而不是一个构造器, it also creates and initializes a new Array object. Thus the function call Array(…) is equivalent to the object creation expression new Array(…) with the same arguments.

The Array 构造器 is a single function whose behaviour is overloaded based upon the number and types of its arguments.

The Array 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that intend to inherit the exotic Array behaviour must include a super call to the Array 构造器 to initialize subclass instances that are Array 外来对象. However, most of the Array.prototype methods are generic methods that are not dependent upon their this value being an Array 外来对象.

The length property of the Array 构造器 function is 1.

22.1.1.1Array ( )

This description applies if and only if the Array 构造器 is called with no arguments.

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs = 0.
If NewTarget is undefined, let newTarget be the active 函数对象, else let newTarget be NewTarget.
Let proto be ? GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
Return ! ArrayCreate(0, proto).

22.1.1.2Array ( `len` )

This description applies if and only if the Array 构造器 is called with exactly one argument.

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs = 1.
If NewTarget is undefined, let newTarget be the active 函数对象, else let newTarget be NewTarget.
Let proto be ? GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
Let array be ! ArrayCreate(0, proto).
If Type(len) is not Number, then
1. Let defineStatus be CreateDataProperty(array, "0", len).
2. Assert: defineStatus is true.
3. Let intLen be 1.
Else,
1. Let intLen be ToUint32(len).
2. If intLen ≠ len, 抛出一个 RangeError 异常.
Perform ! Set(array, "length", intLen, true).
Return array.

22.1.1.3Array ( ...`items` )

This description applies if and only if the Array 构造器 is called with at least two arguments.

When the Array function is called, 执行如下:

Let numberOfArgs be the number of arguments passed to this function call.
Assert: numberOfArgs ≥ 2.
If NewTarget is undefined, let newTarget be the active 函数对象, else let newTarget be NewTarget.
Let proto be ? GetPrototypeFromConstructor(newTarget, "%ArrayPrototype%").
Let array be ? ArrayCreate(numberOfArgs, proto).
Let k be 0.
Let items be a zero-origined List containing the argument items in order.
Repeat, while k < numberOfArgs
1. Let Pk be ! ToString(k).
2. Let itemK be items[k].
3. Let defineStatus be CreateDataProperty(array, Pk, itemK).
4. Assert: defineStatus is true.
5. Increase k by 1.
Assert: The value of array's length property is numberOfArgs.
Return array.

22.1.2Array 构造器的属性

[[Prototype]] 内部属性的值 of the Array 构造器 is the 内部对象 %FunctionPrototype%.

The Array 构造器有以下属性:

22.1.2.1Array.from ( `items` [ , `mapfn` [ , `thisArg` ] ] )

When the from method is called with argument items and 可选参数 mapfn and thisArg, 执行如下:

Let C be the this value.
If mapfn is undefined, let mapping be false.
Else,
1. If IsCallable(mapfn) is false, 抛出一个 TypeError 异常.
2. If thisArg is present, let T be thisArg; else let T be undefined.
3. Let mapping be true.
Let usingIterator be ? GetMethod(items, @@迭代器).
If usingIterator is not undefined, then
1. If IsConstructor(C) is true, then
  1. Let A be ? Construct(C).
2. Else,
  1. Let A be ! ArrayCreate(0).
3. Let iteratorRecord be ? GetIterator(items, sync, usingIterator).
4. Let k be 0.
5. Repeat,
  1. If k ≥ 2⁵³-1, then
    1. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
    2. Return ? IteratorClose(iteratorRecord, error).
  2. Let Pk be ! ToString(k).
  3. Let next be ? IteratorStep(iteratorRecord).
  4. If next is false, then
    1. Perform ? Set(A, "length", k, true).
    2. Return A.
  5. Let nextValue be ? IteratorValue(next).
  6. If mapping is true, then
    1. Let mappedValue be Call(mapfn, T, « nextValue, k »).
    2. If mappedValue is an abrupt completion, return ? IteratorClose(iteratorRecord, mappedValue).
    3. Let mappedValue be mappedValue.[[Value]].
  7. Else, let mappedValue be nextValue.
  8. Let defineStatus be CreateDataPropertyOrThrow(A, Pk, mappedValue).
  9. If defineStatus is an abrupt completion, return ? IteratorClose(iteratorRecord, defineStatus).
  10. Increase k by 1.
NOTE: items is not an Iterable so assume it is an array-like object.
Let arrayLike be ! ToObject(items).
Let len be ? ToLength(? Get(arrayLike, "length")).
If IsConstructor(C) is true, then
1. Let A be ? Construct(C, « len »).
Else,
1. Let A be ? ArrayCreate(len).
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(arrayLike, Pk).
3. If mapping is true, then
  1. Let mappedValue be ? Call(mapfn, T, « kValue, k »).
4. Else, let mappedValue be kValue.
5. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
6. Increase k by 1.
Perform ? Set(A, "length", len, true).
Return A.

Note

The from function is an intentionally generic factory method; 不需要 its this value be the Array 构造器. Therefore it can be transferred to or inherited by any other constructors that may be called with a single numeric argument.

22.1.2.2Array.isArray ( `arg` )

The isArray function takes one argument arg, and 执行如下:

Return ? IsArray(arg).

22.1.2.3Array.of ( ...`items` )

When the of method is called with any number of arguments, 执行如下:

Let len be the actual number of arguments passed to this function.
Let items be the List of arguments passed to this function.
Let C be the this value.
If IsConstructor(C) is true, then
1. Let A be ? Construct(C, « len »).
Else,
1. Let A be ? ArrayCreate(len).
Let k be 0.
Repeat, while k < len
1. Let kValue be items[k].
2. Let Pk be ! ToString(k).
3. Perform ? CreateDataPropertyOrThrow(A, Pk, kValue).
4. Increase k by 1.
Perform ? Set(A, "length", len, true).
Return A.

Note 1

The items argument is assumed to be a well-formed rest argument value.

Note 2

The of function is an intentionally generic factory method; 不需要 its this value be the Array 构造器. Therefore it can be transferred to or inherited by other constructors that may be called with a single numeric argument.

22.1.2.4Array.prototype

The value of Array.prototype is %ArrayPrototype%, the intrinsic Array 原型对象.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

22.1.2.5get Array [ @@species ]

Array[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

Array prototype methods normally use their this object's 构造器 to create a derived object. However, a subclass 构造器 may over-ride that default behaviour by redefining its @@species property.

22.1.3Array 原型对象的属性

The Array 原型对象 is the 内部对象 %ArrayPrototype%. The Array 原型对象 is an Array 外来对象 and has the 内部方法 specified for such objects. It has a length property whose 初始值 is 0 and whose 特性 are { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

[[Prototype]] 内部属性的值 of the Array 原型对象 is the 内部对象 %ObjectPrototype%.

Note

The Array 原型对象 is specified to be an Array 外来对象 to ensure compatibility with ES 代码 that was created prior to the ES 2015 specification.

22.1.3.1Array.prototype.concat ( ...`arguments` )

When the concat 方法以零个或多个参数的形式被调用, it returns an array containing the array elements of the object followed by the array elements of each argument in order.

执行如下:

Let O be ? ToObject(this value).
Let A be ? ArraySpeciesCreate(O, 0).
Let n be 0.
Let items be a List whose first element is O and whose subsequent elements are, in left to right order, the arguments that were passed to this function invocation.
Repeat, while items is not empty
1. Remove the first element from items and let E be the value of the element.
2. Let spreadable be ? IsConcatSpreadable(E).
3. If spreadable is true, then
  1. Let k be 0.
  2. Let len be ? ToLength(? Get(E, "length")).
  3. If n + len > 2⁵³-1, 抛出一个 TypeError 异常.
  4. Repeat, while k < len
    1. Let P be ! ToString(k).
    2. Let exists be ? HasProperty(E, P).
    3. If exists is true, then
      1. Let subElement be ? Get(E, P).
      2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), subElement).
    4. Increase n by 1.
    5. Increase k by 1.
4. Else E is added as a single item rather than spread,
  1. If n≥2⁵³-1, 抛出一个 TypeError 异常.
  2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), E).
  3. Increase n by 1.
Perform ? Set(A, "length", n, true).
Return A.

The length property of the concat method is 1.

Note 1

The explicit setting of the length property in step 6 is necessary to ensure that its value is correct in situations where the trailing elements of the result Array are not present.

Note 2

The concat function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.1.1运行时语义: IsConcatSpreadable ( `O` )

The 抽象操作 IsConcatSpreadable with argument O 执行如下:

If Type(O) is not Object, return false.
Let spreadable be ? Get(O, @@isConcatSpreadable).
If spreadable is not undefined, return ToBoolean(spreadable).
Return ? IsArray(O).

22.1.3.2Array.prototype.constructor

The 初始值 of Array.prototype.constructor is the 内部对象 %Array%.

22.1.3.3Array.prototype.copyWithin ( `target`, `start` [ , `end` ] )

The copyWithin method takes up to three arguments target, start and end.

Note 1

The end argument is optional with the length of the this object as its 默认值. If target is negative, it is treated as length+target where length is the length of the array. If start is negative, it is treated as length+start. If end is negative, it is treated as length+end.

执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let relativeTarget be ? ToInteger(target).
If relativeTarget < 0, let to be max((len + relativeTarget), 0); else let to be min(relativeTarget, len).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let from be max((len + relativeStart), 0); else let from be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let count be min(final-from, len-to).
If from<to and to<from+count, then
1. Let direction be -1.
2. Let from be from + count - 1.
3. Let to be to + count - 1.
Else,
1. Let direction be 1.
Repeat, while count > 0
1. Let fromKey be ! ToString(from).
2. Let toKey be ! ToString(to).
3. Let fromPresent be ? HasProperty(O, fromKey).
4. If fromPresent is true, then
  1. Let fromVal be ? Get(O, fromKey).
  2. Perform ? Set(O, toKey, fromVal, true).
5. Else fromPresent is false,
  1. Perform ? DeletePropertyOrThrow(O, toKey).
6. Let from be from + direction.
7. Let to be to + direction.
8. Let count be count - 1.
Return O.

Note 2

The copyWithin function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.4Array.prototype.entries ( )

执行如下:

Let O be ? ToObject(this value).
Return CreateArrayIterator(O, "key+value").

This function is the %ArrayProto_entries% 内部对象.

22.1.3.5Array.prototype.every ( `callbackfn` [ , `thisArg` ] )

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean 值 true or false. every calls callbackfn once for each element present in the array, in ascending order, until it finds one where callbackfn returns false. If such an element is found, every immediately returns false. Otherwise, if callbackfn returned true for all elements, every will return true. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

every does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by every is set before the first call to callbackfn. Elements which are appended to the array after the call to every begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time every visits them; elements that are deleted after the call to every begins and before being visited are not visited. every acts like the "for all" quantifier in mathematics. In particular, for an empty array, it returns true.

When the every method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Let testResult be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
  3. If testResult is false, return false.
4. Increase k by 1.
Return true.

Note 2

The every function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.6Array.prototype.fill ( `value` [ , `start` [ , `end` ] ] )

The fill method takes up to three arguments value, start and end.

Note 1

The start and end arguments are optional with default values of 0 and the length of the this object. If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end.

执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Repeat, while k < final
1. Let Pk be ! ToString(k).
2. Perform ? Set(O, Pk, value, true).
3. Increase k by 1.
Return O.

Note 2

The fill function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.7Array.prototype.filter ( `callbackfn` [ , `thisArg` ] )

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean 值 true or false. filter calls callbackfn once for each element in the array, in ascending order, and constructs a new array of all the values for which callbackfn returns true. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

filter does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by filter is set before the first call to callbackfn. Elements which are appended to the array after the call to filter begins will not be visited by callbackfn. If existing elements of the array are changed their value as passed to callbackfn will be the value at the time filter visits them; elements that are deleted after the call to filter begins and before being visited are not visited.

When the filter method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let A be ? ArraySpeciesCreate(O, 0).
Let k be 0.
Let to be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Let selected be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
  3. If selected is true, then
    1. Perform ? CreateDataPropertyOrThrow(A, ! ToString(to), kValue).
    2. Increase to by 1.
4. Increase k by 1.
Return A.

Note 2

The filter function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.8Array.prototype.find ( `predicate` [ , `thisArg` ] )

The find method is called with one or two arguments, predicate and thisArg.

Note 1

predicate should be a function that accepts three arguments and returns a value that is coercible to a Boolean 值. find calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, find immediately returns that element value. Otherwise, find returns undefined.

If a thisArg parameter is provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.

predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.

find does not directly mutate the object on which it is called but the object may be mutated by the calls to predicate.

The range of elements processed by find is set before the first call to predicate. Elements that are appended to the array after the call to find begins will not be visited by predicate. If existing elements of the array are changed, their value as passed to predicate will be the value at the time that find visits them.

When the find method is called, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(predicate) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(O, Pk).
3. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
4. If testResult is true, return kValue.
5. Increase k by 1.
Return undefined.

Note 2

The find function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.9Array.prototype.findIndex ( `predicate` [ , `thisArg` ] )

Note 1

predicate should be a function that accepts three arguments and returns a value that is coercible to the Boolean 值 true or false. findIndex calls predicate once for each element of the array, in ascending order, until it finds one where predicate returns true. If such an element is found, findIndex immediately returns the index of that element value. Otherwise, findIndex returns -1.

If a thisArg parameter is provided, it will be used as the this value for each invocation of predicate. If it is not provided, undefined is used instead.

predicate is called with three arguments: the value of the element, the index of the element, and the object being traversed.

findIndex does not directly mutate the object on which it is called but the object may be mutated by the calls to predicate.

The range of elements processed by findIndex is set before the first call to predicate. Elements that are appended to the array after the call to findIndex begins will not be visited by predicate. If existing elements of the array are changed, their value as passed to predicate will be the value at the time that findIndex visits them.

When the findIndex method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(predicate) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(O, Pk).
3. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
4. If testResult is true, return k.
5. Increase k by 1.
Return -1.

Note 2

The findIndex function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.10Array.prototype.forEach ( `callbackfn` [ , `thisArg` ] )

Note 1

callbackfn should be a function that accepts three arguments. forEach calls callbackfn once for each element present in the array, in ascending order. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

forEach does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

When the forEach method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Perform ? Call(callbackfn, T, « kValue, k, O »).
4. Increase k by 1.
Return undefined.

This function is the %ArrayProto_forEach% 内部对象.

Note 2

The forEach function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.11Array.prototype.includes ( `searchElement` [ , `fromIndex` ] )

Note 1

includes compares searchElement to the elements of the array, in ascending order, using the SameValueZero 算法, and if found at any position, returns true; otherwise, false is returned.

The optional second argument fromIndex defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, false is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, the whole array will be searched.

When the includes method is called, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If len is 0, return false.
Let n be ? ToInteger(fromIndex). (If fromIndex is undefined, this step produces the value 0.)
If n ≥ 0, then
1. Let k be n.
Else n < 0,
1. Let k be len + n.
2. If k < 0, let k be 0.
Repeat, while k < len
1. Let elementK be the result of ? Get(O, ! ToString(k)).
2. If SameValueZero(searchElement, elementK) is true, return true.
3. Increase k by 1.
Return false.

Note 2

The includes function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

Note 3

The includes method intentionally differs from the similar indexOf method in two ways. First, it uses the SameValueZero 算法, instead of 严格相等比较, allowing it to detect NaN array elements. Second, it does not skip missing array elements, instead treating them as undefined.

22.1.3.12Array.prototype.indexOf ( `searchElement` [ , `fromIndex` ] )

Note 1

indexOf compares searchElement to the elements of the array, in ascending order, using the 严格相等比较算法, and if found at one or more indices, returns the smallest such index; otherwise, -1 is returned.

The optional second argument fromIndex defaults to 0 (i.e. the whole array is searched). If it is greater than or equal to the length of the array, -1 is returned, i.e. the array will not be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, the whole array will be searched.

When the indexOf method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If len is 0, return -1.
Let n be ? ToInteger(fromIndex). (If fromIndex is undefined, this step produces the value 0.)
If n ≥ len, return -1.
If n ≥ 0, then
1. If n is -0, let k be +0; else let k be n.
Else n < 0,
1. Let k be len + n.
2. If k < 0, let k be 0.
Repeat, while k < len
1. Let kPresent be ? HasProperty(O, ! ToString(k)).
2. If kPresent is true, then
  1. Let elementK be ? Get(O, ! ToString(k)).
  2. Let same be the result of performing 严格相等比较 searchElement === elementK.
  3. If same is true, return k.
3. Increase k by 1.
Return -1.

Note 2

The indexOf function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.13Array.prototype.join ( `separator` )

Note 1

The elements of the array are converted to Strings, and these Strings are then concatenated, separated by occurrences of the separator. If no separator is provided, a single comma is used as the separator.

The join method takes one argument, separator, and 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If separator is undefined, let sep be the single-element String ",".
Else, let sep be ? ToString(separator).
Let R be the empty String.
Let k be 0.
Repeat, while k < len
1. If k > 0, let R be the string-concatenation of R and sep.
2. Let element be ? Get(O, ! ToString(k)).
3. If element is undefined or null, let next be the empty String; otherwise, let next be ? ToString(element).
4. Set R to the string-concatenation of R and next.
5. Increase k by 1.
Return R.

Note 2

The join function 是故意通用的; 不需要 its this value be an Array object. Therefore, 它可以转换为其它对象类型的方法而被使用.

22.1.3.14Array.prototype.keys ( )

执行如下:

Let O be ? ToObject(this value).
Return CreateArrayIterator(O, "key").

This function is the %ArrayProto_keys% 内部对象.

22.1.3.15Array.prototype.lastIndexOf ( `searchElement` [ , `fromIndex` ] )

Note 1

lastIndexOf compares searchElement to the elements of the array in descending order using the 严格相等比较算法, and if found at one or more indices, returns the largest such index; otherwise, -1 is returned.

The optional second argument fromIndex defaults to the array's length minus one (i.e. the whole array is searched). If it is greater than or equal to the length of the array, the whole array will be searched. If it is negative, it is used as the offset from the end of the array to compute fromIndex. If the computed index is less than 0, -1 is returned.

When the lastIndexOf method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If len is 0, return -1.
If fromIndex is present, let n be ? ToInteger(fromIndex); else let n be len-1.
If n ≥ 0, then
1. If n is -0, let k be +0; else let k be min(n, len - 1).
Else n < 0,
1. Let k be len + n.
Repeat, while k ≥ 0
1. Let kPresent be ? HasProperty(O, ! ToString(k)).
2. If kPresent is true, then
  1. Let elementK be ? Get(O, ! ToString(k)).
  2. Let same be the result of performing 严格相等比较 searchElement === elementK.
  3. If same is true, return k.
3. Decrease k by 1.
Return -1.

Note 2

The lastIndexOf function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.16Array.prototype.map ( `callbackfn` [ , `thisArg` ] )

Note 1

callbackfn should be a function that accepts three arguments. map calls callbackfn once for each element in the array, in ascending order, and constructs a new Array from the results. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

map does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by map is set before the first call to callbackfn. Elements which are appended to the array after the call to map begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time map visits them; elements that are deleted after the call to map begins and before being visited are not visited.

When the map method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let A be ? ArraySpeciesCreate(O, len).
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Let mappedValue be ? Call(callbackfn, T, « kValue, k, O »).
  3. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
4. Increase k by 1.
Return A.

Note 2

The map function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.17Array.prototype.pop ( )

Note 1

The last element of the array is removed from the array and returned.

When the pop method is called, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If len is zero, then
1. Perform ? Set(O, "length", 0, true).
2. Return undefined.
Else len > 0,
1. Let newLen be len-1.
2. Let index be ! ToString(newLen).
3. Let element be ? Get(O, index).
4. Perform ? DeletePropertyOrThrow(O, index).
5. Perform ? Set(O, "length", newLen, true).
6. Return element.

Note 2

The pop function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.18Array.prototype.push ( ...`items` )

Note 1

The arguments are appended to the end of the array, in the order in which they appear. The new length of the array is returned as the result of the call.

When the push 方法以零个或多个参数的形式被调用, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let items be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
Let argCount be the number of elements in items.
If len + argCount > 2⁵³-1, 抛出一个 TypeError 异常.
Repeat, while items is not empty
1. Remove the first element from items and let E be the value of the element.
2. Perform ? Set(O, ! ToString(len), E, true).
3. Let len be len+1.
Perform ? Set(O, "length", len, true).
Return len.

The length property of the push method is 1.

Note 2

The push function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.19Array.prototype.reduce ( `callbackfn` [ , `initialValue` ] )

Note 1

callbackfn should be a function that takes four arguments. reduce calls the callback, as a function, once for each element after the first element present in the array, in ascending order.

callbackfn is called with four arguments: the previousValue (value from the previous call to callbackfn), the currentValue (value of the current element), the currentIndex, and the object being traversed. The first time that callback is called, the previousValue and currentValue can be one of two values. If an initialValue was supplied in the call to reduce, then previousValue will be equal to initialValue and currentValue will be equal to the first value in the array. If no initialValue was supplied, then previousValue will be equal to the first value in the array and currentValue will be equal to the second. It is a TypeError if the array contains no elements and initialValue is not provided.

reduce does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by reduce is set before the first call to callbackfn. Elements that are appended to the array after the call to reduce begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time reduce visits them; elements that are deleted after the call to reduce begins and before being visited are not visited.

When the reduce method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If len is 0 and initialValue is not present, 抛出一个 TypeError 异常.
Let k be 0.
Let accumulator be undefined.
If initialValue is present, then
1. Set accumulator to initialValue.
Else initialValue is not present,
1. Let kPresent be false.
2. Repeat, while kPresent is false and k < len
  1. Let Pk be ! ToString(k).
  2. Let kPresent be ? HasProperty(O, Pk).
  3. If kPresent is true, then
    1. Set accumulator to ? Get(O, Pk).
  4. Increase k by 1.
3. If kPresent is false, 抛出一个 TypeError 异常.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
4. Increase k by 1.
Return accumulator.

Note 2

The reduce function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.20Array.prototype.reduceRight ( `callbackfn` [ , `initialValue` ] )

Note 1

callbackfn should be a function that takes four arguments. reduceRight calls the callback, as a function, once for each element after the first element present in the array, in descending order.

callbackfn is called with four arguments: the previousValue (value from the previous call to callbackfn), the currentValue (value of the current element), the currentIndex, and the object being traversed. The first time the function is called, the previousValue and currentValue can be one of two values. If an initialValue was supplied in the call to reduceRight, then previousValue will be equal to initialValue and currentValue will be equal to the last value in the array. If no initialValue was supplied, then previousValue will be equal to the last value in the array and currentValue will be equal to the second-to-last value. It is a TypeError if the array contains no elements and initialValue is not provided.

reduceRight does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by reduceRight is set before the first call to callbackfn. Elements that are appended to the array after the call to reduceRight begins will not be visited by callbackfn. If existing elements of the array are changed by callbackfn, their value as passed to callbackfn will be the value at the time reduceRight visits them; elements that are deleted after the call to reduceRight begins and before being visited are not visited.

When the reduceRight method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If len is 0 and initialValue is not present, 抛出一个 TypeError 异常.
Let k be len-1.
Let accumulator be undefined.
If initialValue is present, then
1. Set accumulator to initialValue.
Else initialValue is not present,
1. Let kPresent be false.
2. Repeat, while kPresent is false and k ≥ 0
  1. Let Pk be ! ToString(k).
  2. Let kPresent be ? HasProperty(O, Pk).
  3. If kPresent is true, then
    1. Set accumulator to ? Get(O, Pk).
  4. Decrease k by 1.
3. If kPresent is false, 抛出一个 TypeError 异常.
Repeat, while k ≥ 0
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
4. Decrease k by 1.
Return accumulator.

Note 2

The reduceRight function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.21Array.prototype.reverse ( )

Note 1

The elements of the array are rearranged so as to reverse their order. The object is returned as the result of the call.

When the reverse method is called, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let middle be floor(len/2).
Let lower be 0.
Repeat, while lower ≠ middle
1. Let upper be len - lower - 1.
2. Let upperP be ! ToString(upper).
3. Let lowerP be ! ToString(lower).
4. Let lowerExists be ? HasProperty(O, lowerP).
5. If lowerExists is true, then
  1. Let lowerValue be ? Get(O, lowerP).
6. Let upperExists be ? HasProperty(O, upperP).
7. If upperExists is true, then
  1. Let upperValue be ? Get(O, upperP).
8. If lowerExists is true and upperExists is true, then
  1. Perform ? Set(O, lowerP, upperValue, true).
  2. Perform ? Set(O, upperP, lowerValue, true).
9. Else if lowerExists is false and upperExists is true, then
  1. Perform ? Set(O, lowerP, upperValue, true).
  2. Perform ? DeletePropertyOrThrow(O, upperP).
10. Else if lowerExists is true and upperExists is false, then
  1. Perform ? DeletePropertyOrThrow(O, lowerP).
  2. Perform ? Set(O, upperP, lowerValue, true).
11. Else both lowerExists and upperExists are false,
  1. No action is required.
12. Increase lower by 1.
Return O.

Note 2

The reverse function 是故意通用的; 不需要 its this value be an Array object. Therefore, 它可以转换为其它对象类型的方法而被使用.

22.1.3.22Array.prototype.shift ( )

Note 1

The first element of the array is removed from the array and returned.

When the shift method is called, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If len is zero, then
1. Perform ? Set(O, "length", 0, true).
2. Return undefined.
Let first be ? Get(O, "0").
Let k be 1.
Repeat, while k < len
1. Let from be ! ToString(k).
2. Let to be ! ToString(k-1).
3. Let fromPresent be ? HasProperty(O, from).
4. If fromPresent is true, then
  1. Let fromVal be ? Get(O, from).
  2. Perform ? Set(O, to, fromVal, true).
5. Else fromPresent is false,
  1. Perform ? DeletePropertyOrThrow(O, to).
6. Increase k by 1.
Perform ? DeletePropertyOrThrow(O, ! ToString(len-1)).
Perform ? Set(O, "length", len-1, true).
Return first.

Note 2

The shift function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.23Array.prototype.slice ( `start`, `end` )

Note 1

The slice method takes two arguments, start and end, and returns an array containing the elements of the array from element start up to, but not including, element end (or through the end of the array if end is undefined). If start is negative, it is treated as length+start where length is the length of the array. If end is negative, it is treated as length+end where length is the length of the array.

执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let count be max(final - k, 0).
Let A be ? ArraySpeciesCreate(O, count).
Let n be 0.
Repeat, while k < final
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(n), kValue).
4. Increase k by 1.
5. Increase n by 1.
Perform ? Set(A, "length", n, true).
Return A.

Note 2

The explicit setting of the length property of the result Array in step 11 was necessary in previous editions of ES to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting length became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.

Note 3

The slice function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.24Array.prototype.some ( `callbackfn` [ , `thisArg` ] )

Note 1

callbackfn should be a function that accepts three arguments and returns a value that is coercible to the Boolean 值 true or false. some calls callbackfn once for each element present in the array, in ascending order, until it finds one where callbackfn returns true. If such an element is found, some immediately returns true. Otherwise, some returns false. callbackfn is called only for elements of the array which actually exist; it is not called for missing elements of the array.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the element, the index of the element, and the object being traversed.

some does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

The range of elements processed by some is set before the first call to callbackfn. Elements that are appended to the array after the call to some begins will not be visited by callbackfn. If existing elements of the array are changed, their value as passed to callbackfn will be the value at the time that some visits them; elements that are deleted after the call to some begins and before being visited are not visited. some acts like the "exists" quantifier in mathematics. In particular, for an empty array, it returns false.

When the some method is called with one or two arguments, 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kPresent be ? HasProperty(O, Pk).
3. If kPresent is true, then
  1. Let kValue be ? Get(O, Pk).
  2. Let testResult be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
  3. If testResult is true, return true.
4. Increase k by 1.
Return false.

Note 2

The some function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.25Array.prototype.sort ( `comparefn` )

The elements of this array are sorted. The sort is not necessarily stable (that is, elements that compare equal do not necessarily remain in their original order). If comparefn is not undefined, it should be a function that accepts two arguments x and y and returns a negative value if x < y, zero if x = y, or a positive value if x > y.

Upon entry, the following steps are performed to initialize 估值 of the sort function:

If comparefn is not undefined and IsCallable(comparefn) is false, 抛出一个 TypeError 异常.
Let obj be ? ToObject(this value).
Let len be ? ToLength(? Get(obj, "length")).

Within this specification of the sort method, an object, obj, is said to be sparse if the following 算法 returns true:

For each integer i in the range 0≤i< len, do
1. Let elem be obj.[[GetOwnProperty]](! ToString(i)).
2. If elem is undefined, return true.
Return false.

The sort order is the ordering, after completion of this function, of the integer-indexed property values of obj whose integer indexes are less than len. The result of the sort function is then determined as follows:

If comparefn is not undefined and is not a consistent comparison function for the elements of this array (see below), the sort order is 实现-defined. The sort order is also 实现-defined if comparefn is undefined and SortCompare does not act as a consistent comparison function.

Let proto be obj.[[GetPrototypeOf]](). If proto is not null and there exists an integer j such that all of the conditions below are satisfied then the sort order is 实现-defined:

obj is sparse
0 ≤ j < len
HasProperty(proto, ToString(j)) is true.

The sort order is also 实现-defined if obj is sparse and any of the following conditions are true:

IsExtensible(obj) is false.
Any 整数索引 property of obj whose name is 一个非负整数 less than len is a 数据属性 whose [[Configurable]] 特性 is false.

The sort order is also 实现-defined if any of the following conditions are true:

If obj is an 外来对象 (including Proxy 外来对象) whose behaviour for [[Get]], [[Set]], [[Delete]], and [[GetOwnProperty]] is not the 普通对象实现 of these 内部方法.
If any index property of obj whose name is 一个非负整数 less than len is an 访问器属性 or is a 数据属性 whose [[Writable]] 特性 is false.
If comparefn is undefined and the application of ToString to any value passed as an argument to SortCompare modifies obj or any object on obj's prototype chain.
If comparefn is undefined and all applications of ToString, to any specific value passed as an argument to SortCompare, do not produce the same result.

执行如下:

Perform an 实现-dependent sequence of calls to the [[Get]] and [[Set]] 内部方法 of obj, to the DeletePropertyOrThrow and HasOwnProperty 抽象操作 with obj as the first argument, and to SortCompare (described below), such that:
- The property key argument for each call to [[Get]], [[Set]], HasOwnProperty, or DeletePropertyOrThrow is the string representation of 一个非负整数 less than len.
- The arguments for calls to SortCompare are values returned by a previous call to the [[Get]] 内部方法, unless the properties accessed by those previous calls did not exist according to HasOwnProperty. If both perspective arguments to SortCompare correspond to non-existent properties, use +0 instead of calling SortCompare. If only the first perspective argument is non-existent use +1. If only the second perspective argument is non-existent use -1.
- If obj is not sparse then DeletePropertyOrThrow must not be called.
- If any [[Set]] call returns false a TypeError 异常 is thrown.
- If an abrupt completion is returned from any of these operations, it is immediately returned as the value of this function.
Return obj.

Unless the sort order is specified above to be 实现-defined, the returned object must have the following two characteristics:

There must be some mathematical permutation π of the nonnegative integers less than len, such that for every nonnegative integer j less than len, if property old[j] existed, then new[π(j)] is exactly the same value as old[j]. But if property old[j] did not exist, then new[π(j)] does not exist.
Then for all nonnegative integers j and k, each less than len, if SortCompare(old[j], old[k]) < 0 (see SortCompare below), then new[π(j)] < new[π(k)].

Here the notation old[j] is used to refer to the hypothetical result of calling obj.[[Get]](j) before this function is executed, and the notation new[j] to refer to the hypothetical result of calling obj.[[Get]](j) after this function has been executed.

A function comparefn is a consistent comparison function for a set of values S if all of the requirements below are met for all values a, b, and c (possibly the same value) in the set S: The notation a <_CF b means comparefn(a, b) < 0; a =_CF b means comparefn(a, b) = 0 (of either sign); and a >_CF b means comparefn(a, b) > 0.

Calling comparefn(a, b) always returns the same value v when given a specific pair of values a and b as its two arguments. Furthermore, Type(v) is Number, and v is not NaN. Note that this implies that exactly one of a <_CF b, a =_CF b, and a >_CF b will be true for a given pair of a and b.
Calling comparefn(a, b) does not modify obj or any object on obj's prototype chain.
a =_CF a (reflexivity)
If a =_CF b, then b =_CF a (symmetry)
If a =_CF b and b =_CF c, then a =_CF c (transitivity of =_CF)
If a <_CF b and b <_CF c, then a <_CF c (transitivity of <_CF)
If a >_CF b and b >_CF c, then a >_CF c (transitivity of >_CF)

Note 1

The above conditions are necessary and sufficient to ensure that comparefn divides the set S into equivalence classes and that these equivalence classes are totally ordered.

Note 2

The sort function 是故意通用的; 不需要 its this value be an Array object. Therefore, 它可以转换为其它对象类型的方法而被使用.

22.1.3.25.1运行时语义: SortCompare( `x`, `y` )

The SortCompare 抽象操作 is called with two arguments x and y. It also has access to the comparefn argument passed to the current invocation of the sort method. 执行如下:

If x and y are both undefined, return +0.
If x is undefined, return 1.
If y is undefined, return -1.
If comparefn is not undefined, then
1. Let v be ? ToNumber(? Call(comparefn, undefined, « x, y »)).
2. If v is NaN, return +0.
3. Return v.
Let xString be ? ToString(x).
Let yString be ? ToString(y).
Let xSmaller be the result of performing 抽象关系比较 xString < yString.
If xSmaller is true, return -1.
Let ySmaller be the result of performing 抽象关系比较 yString < xString.
If ySmaller is true, return 1.
Return +0.

Note 1

Because non-existent property values always compare greater than undefined property values, and undefined always compares greater than any other value, undefined property values always sort to the end of the result, followed by non-existent property values.

Note 2

Method calls performed by the ToString 抽象操作 in steps 5 and 7 have the potential to cause SortCompare to not behave as a consistent comparison function.

22.1.3.26Array.prototype.splice ( `start`, `deleteCount`, ...`items` )

Note 1

When the splice method is called with two or more arguments start, deleteCount and zero or more items, the deleteCount elements of the array starting at 整数索引 start are replaced by the arguments items. An Array object containing the deleted elements (if any) is returned.

执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let actualStart be max((len + relativeStart), 0); else let actualStart be min(relativeStart, len).
If the number of actual arguments is 0, then
1. Let insertCount be 0.
2. Let actualDeleteCount be 0.
Else if the number of actual arguments is 1, then
1. Let insertCount be 0.
2. Let actualDeleteCount be len - actualStart.
Else,
1. Let insertCount be the number of actual arguments minus 2.
2. Let dc be ? ToInteger(deleteCount).
3. Let actualDeleteCount be min(max(dc, 0), len - actualStart).
If len+insertCount-actualDeleteCount > 2⁵³-1, 抛出一个 TypeError 异常.
Let A be ? ArraySpeciesCreate(O, actualDeleteCount).
Let k be 0.
Repeat, while k < actualDeleteCount
1. Let from be ! ToString(actualStart+k).
2. Let fromPresent be ? HasProperty(O, from).
3. If fromPresent is true, then
  1. Let fromValue be ? Get(O, from).
  2. Perform ? CreateDataPropertyOrThrow(A, ! ToString(k), fromValue).
4. Increment k by 1.
Perform ? Set(A, "length", actualDeleteCount, true).
Let items be a List whose elements are, in left to right order, the portion of the actual argument list starting with the third argument. The list is empty if fewer than three arguments were passed.
Let itemCount be the number of elements in items.
If itemCount < actualDeleteCount, then
1. Let k be actualStart.
2. Repeat, while k < (len - actualDeleteCount)
  1. Let from be ! ToString(k+actualDeleteCount).
  2. Let to be ! ToString(k+itemCount).
  3. Let fromPresent be ? HasProperty(O, from).
  4. If fromPresent is true, then
    1. Let fromValue be ? Get(O, from).
    2. Perform ? Set(O, to, fromValue, true).
  5. Else fromPresent is false,
    1. Perform ? DeletePropertyOrThrow(O, to).
  6. Increase k by 1.
3. Let k be len.
4. Repeat, while k > (len - actualDeleteCount + itemCount)
  1. Perform ? DeletePropertyOrThrow(O, ! ToString(k-1)).
  2. Decrease k by 1.
Else if itemCount > actualDeleteCount, then
1. Let k be (len - actualDeleteCount).
2. Repeat, while k > actualStart
  1. Let from be ! ToString(k + actualDeleteCount - 1).
  2. Let to be ! ToString(k + itemCount - 1).
  3. Let fromPresent be ? HasProperty(O, from).
  4. If fromPresent is true, then
    1. Let fromValue be ? Get(O, from).
    2. Perform ? Set(O, to, fromValue, true).
  5. Else fromPresent is false,
    1. Perform ? DeletePropertyOrThrow(O, to).
  6. Decrease k by 1.
Let k be actualStart.
Repeat, while items is not empty
1. Remove the first element from items and let E be the value of that element.
2. Perform ? Set(O, ! ToString(k), E, true).
3. Increase k by 1.
Perform ? Set(O, "length", len - actualDeleteCount + itemCount, true).
Return A.

Note 2

The explicit setting of the length property of the result Array in step 19 was necessary in previous editions of ES to ensure that its length was correct in situations where the trailing elements of the result Array were not present. Setting length became unnecessary starting in ES2015 when the result Array was initialized to its proper length rather than an empty Array but is carried forward to preserve backward compatibility.

Note 3

The splice function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.27Array.prototype.toLocaleString ( [ `reserved1` [ , `reserved2` ] ] )

An ES 实现 that includes the ECMA-402 Internationalization API must implement the Array.prototype.toLocaleString method as specified in the ECMA-402 specification. If an ES 实现 does not include the ECMA-402 API the following specification of the toLocaleString method is used.

Note 1

The first edition of ECMA-402 did not include a replacement specification for the Array.prototype.toLocaleString method.

执行如下:

Let array be ? ToObject(this value).
Let len be ? ToLength(? Get(array, "length")).
Let separator be the String 值 for the list-separator String appropriate for the host environment's current locale (this is derived in an 实现-defined way).
Let R be the empty String.
Let k be 0.
Repeat, while k < len
1. If k > 0, then
  1. Set R to the string-concatenation of R and separator.
2. Let nextElement be ? Get(array, ! ToString(k)).
3. If nextElement is not undefined or null, then
  1. Let S be ? ToString(? Invoke(nextElement, "toLocaleString")).
  2. Set R to the string-concatenation of R and S.
4. Increase k by 1.
Return R.

Note 2

The elements of the array are converted to Strings using their toLocaleString methods, and these Strings are then concatenated, separated by occurrences of a separator String that has been derived in an 实现-defined locale-specific way. The result of calling this function is intended to be analogous to the result of toString, except that the result of this function is intended to be locale-specific.

Note 3

The toLocaleString function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.28Array.prototype.toString ( )

When the toString method is called, 执行如下:

Let array be ? ToObject(this value).
Let func be ? Get(array, "join").
If IsCallable(func) is false, let func be the intrinsic function %ObjProto_toString%.
Return ? Call(func, array).

Note

The toString function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.29Array.prototype.unshift ( ...`items` )

Note 1

The arguments are prepended to the start of the array, such that their order within the array is the same as the order in which they appear in the argument list.

When the unshift 方法以零个或多个参数的形式被调用 item1, item2, etc., 执行如下:

Let O be ? ToObject(this value).
Let len be ? ToLength(? Get(O, "length")).
Let argCount be the number of actual arguments.
If argCount > 0, then
1. If len+argCount > 2⁵³-1, 抛出一个 TypeError 异常.
2. Let k be len.
3. Repeat, while k > 0,
  1. Let from be ! ToString(k-1).
  2. Let to be ! ToString(k+argCount-1).
  3. Let fromPresent be ? HasProperty(O, from).
  4. If fromPresent is true, then
    1. Let fromValue be ? Get(O, from).
    2. Perform ? Set(O, to, fromValue, true).
  5. Else fromPresent is false,
    1. Perform ? DeletePropertyOrThrow(O, to).
  6. Decrease k by 1.
4. Let j be 0.
5. Let items be a List whose elements are, in left to right order, the arguments that were passed to this function invocation.
6. Repeat, while items is not empty
  1. Remove the first element from items and let E be the value of that element.
  2. Perform ? Set(O, ! ToString(j), E, true).
  3. Increase j by 1.
Perform ? Set(O, "length", len+argCount, true).
Return len+argCount.

The length property of the unshift method is 1.

Note 2

The unshift function 是故意通用的; 不需要 its this value be an Array object. Therefore 它可以转换为其它对象类型的方法而被使用.

22.1.3.30Array.prototype.values ( )

执行如下:

Let O be ? ToObject(this value).
Return CreateArrayIterator(O, "value").

This function is the %ArrayProto_values% 内部对象.

22.1.3.31Array.prototype [ @@迭代器 ] ( )

The 初始值 of the @@迭代器 property is the same 函数对象 as the 初始值 of the Array.prototype.values property.

22.1.3.32Array.prototype [ @@unscopables ]

The 初始值 of the @@unscopables 数据属性 is an object created by the following steps:

Let unscopableList be ObjectCreate(null).
Perform CreateDataProperty(unscopableList, "copyWithin", true).
Perform CreateDataProperty(unscopableList, "entries", true).
Perform CreateDataProperty(unscopableList, "fill", true).
Perform CreateDataProperty(unscopableList, "find", true).
Perform CreateDataProperty(unscopableList, "findIndex", true).
Perform CreateDataProperty(unscopableList, "includes", true).
Perform CreateDataProperty(unscopableList, "keys", true).
Perform CreateDataProperty(unscopableList, "values", true).
Assert: Each of the above calls will return true.
Return unscopableList.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

Note

The 自身属性 names of this object are property names that were not included as standard properties of Array.prototype prior to the ES 2015 specification. These names are ignored for with statement binding purposes in order to preserve the behaviour of existing code that might use one of these names as a binding in an outer scope that is shadowed by a with statement whose binding object is an Array object.

22.1.4Array 实例的属性

Array instances are Array 外来对象 and have the 内部方法 specified for such objects. Array instances 继承属性 from the Array 原型对象.

Array instances have a length property, and a set of enumerable properties with array index names.

22.1.4.1length

The length property of an Array instance is a 数据属性 whose value is always numerically greater than the name of every configurable 自身属性 whose name is an array index.

The length property initially has the 特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Reducing the value of the length property has the side-effect of deleting own array elements whose array index is between the old and new length values. However, non-configurable properties can not be deleted. Attempting to set the length property of an Array object to a value that is numerically less than or equal to the largest numeric own 属性名 of an existing non-configurable array-indexed property of the array will result in the length being set to a 数字值 that is one greater than that non-configurable numeric own 属性名. See 9.4.2.1.

22.1.5Array 迭代器对象

An Array 迭代器 is an object, that represents a specific iteration over some specific Array instance object. There is not a named 构造器 for Array 迭代器对象. Instead, Array 迭代器对象 are created by calling certain methods of Array instance objects.

22.1.5.1CreateArrayIterator ( `array`, `kind` )

Several methods of Array 对象 return 迭代器对象. The 抽象操作 CreateArrayIterator with arguments array and kind is used to create such 迭代器对象. It 执行如下:

Assert: Type(array) is Object.
Let 迭代器 be ObjectCreate(%ArrayIteratorPrototype%, « [[IteratedObject]], [[ArrayIteratorNextIndex]], [[ArrayIterationKind]] »).
Set 迭代器.[[IteratedObject]] to array.
Set 迭代器.[[ArrayIteratorNextIndex]] to 0.
Set 迭代器.[[ArrayIterationKind]] to kind.
Return 迭代器.

22.1.5.2The %ArrayIteratorPrototype% Object

All Array 迭代器对象继承属性 from the %ArrayIteratorPrototype% 内部对象. The %ArrayIteratorPrototype% object is an 普通对象 and its [[Prototype]] 内部属性 is the %IteratorPrototype% 内部对象. In addition, %ArrayIteratorPrototype% 有以下属性:

22.1.5.2.1%ArrayIteratorPrototype%.next( )

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have all of the 内部属性 of an Array 迭代器 Instance (22.1.5.3), 抛出一个 TypeError 异常.
Let a be O.[[IteratedObject]].
If a is undefined, return CreateIterResultObject(undefined, true).
Let index be O.[[ArrayIteratorNextIndex]].
Let itemKind be O.[[ArrayIterationKind]].
If a has a [[TypedArrayName]] 内部属性, then
1. If IsDetachedBuffer(a.[[ViewedArrayBuffer]]) is true, 抛出一个 TypeError 异常.
2. Let len be a.[[ArrayLength]].
Else,
1. Let len be ? ToLength(? Get(a, "length")).
If index ≥ len, then
1. Set O.[[IteratedObject]] to undefined.
2. Return CreateIterResultObject(undefined, true).
Set O.[[ArrayIteratorNextIndex]] to index+1.
If itemKind is "key", return CreateIterResultObject(index, false).
Let elementKey be ! ToString(index).
Let elementValue be ? Get(a, elementKey).
If itemKind is "value", let result be elementValue.
Else,
1. Assert: itemKind is "key+value".
2. Let result be CreateArrayFromList(« index, elementValue »).
Return CreateIterResultObject(result, false).

22.1.5.2.2%ArrayIteratorPrototype% [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Array 迭代器".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

22.1.5.3Array 迭代器实例的属性

Array 迭代器实例 are 普通对象 that 继承属性 from the %ArrayIteratorPrototype% 内部对象. Array 迭代器实例 are initially created with the 内部属性 listed in Table 55.

Table 55: 内部属性 of Array 迭代器实例

内部属性	Description
[[IteratedObject]]	The object whose array elements are being iterated.
[[ArrayIteratorNextIndex]]	The 整数索引 of the next 整数索引 to be examined by this iteration.
[[ArrayIterationKind]]	A String 值 that identifies what is returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`.

22.2TypedArray 对象

TypedArray objects present an array-like view of an underlying binary data buffer (24.1). Each element of a TypedArray instance has the same underlying binary scalar data type. There is a distinct TypedArray 构造器, listed in Table 56, for each of the nine supported element types. Each 构造器 in Table 56 has a corresponding distinct 原型对象.

Table 56: The TypedArray Constructors

构造器 Name and Intrinsic	Element Type	Element Size	Conversion Operation	Description	Equivalent C Type
Int8Array %Int8Array%	Int8	1	ToInt8	8-bit 2's complement signed integer	signed char
Uint8Array %Uint8Array%	Uint8	1	ToUint8	8-bit unsigned integer	unsigned char
Uint8ClampedArray %Uint8ClampedArray%	Uint8C	1	ToUint8Clamp	8-bit unsigned integer (clamped conversion)	unsigned char
Int16Array %Int16Array%	Int16	2	ToInt16	16-bit 2's complement signed integer	short
Uint16Array %Uint16Array%	Uint16	2	ToUint16	16-bit unsigned integer	unsigned short
Int32Array %Int32Array%	Int32	4	ToInt32	32-bit 2's complement signed integer	int
Uint32Array %Uint32Array%	Uint32	4	ToUint32	32-bit unsigned integer	unsigned int
Float32Array %Float32Array%	Float32	4		32-bit IEEE floating point	float
Float64Array %Float64Array%	Float64	8		64-bit IEEE floating point	double

In the definitions below, references to TypedArray should be replaced with the appropriate 构造器 name from the above table. The phrase “the element size in bytes” refers to the value in the Element Size column of the table in the row corresponding to the 构造器. The phrase “element Type” refers to the value in the Element Type column for that row.

22.2.1%TypedArray% 内部对象

The %TypedArray% 内部对象 is a 构造器函数对象 that all of the TypedArray 构造器 objects inherit from. %TypedArray% and its corresponding 原型对象 provide common properties that are inherited by all TypedArray constructors and their instances. The %TypedArray% intrinsic does not have a global name or appear as a property of the 全局对象.

The %TypedArray% intrinsic 函数对象 acts as the abstract superclass of the various TypedArray constructors. Because it is an abstract class 构造器 it will throw an error when invoked. The TypedArray constructors do not perform a super call to it.

22.2.1.1%TypedArray% ( )

The %TypedArray% 构造器执行如下:

抛出一个 TypeError 异常.

The length property of the %TypedArray% 构造器 function is 0.

22.2.2Properties of %TypedArray% 内部对象

[[Prototype]] 内部属性的值 of %TypedArray% is the 内部对象 %FunctionPrototype%.

The name property of the %TypedArray% 构造器 function is "TypedArray".

The %TypedArray% 构造器有以下属性:

22.2.2.1%TypedArray%.from ( `source` [ , `mapfn` [ , `thisArg` ] ] )

When the from method is called with argument source, and 可选参数 mapfn and thisArg, 执行如下:

Let C be the this value.
If IsConstructor(C) is false, 抛出一个 TypeError 异常.
If mapfn is present and mapfn is not undefined, then
1. If IsCallable(mapfn) is false, 抛出一个 TypeError 异常.
2. Let mapping be true.
Else, let mapping be false.
If thisArg is present, let T be thisArg; else let T be undefined.
Let usingIterator be ? GetMethod(source, @@迭代器).
If usingIterator is not undefined, then
1. Let values be ? IterableToList(source, usingIterator).
2. Let len be the number of elements in values.
3. Let targetObj be ? TypedArrayCreate(C, «len»).
4. Let k be 0.
5. Repeat, while k < len
  1. Let Pk be ! ToString(k).
  2. Let kValue be the first element of values and remove that element from values.
  3. If mapping is true, then
    1. Let mappedValue be ? Call(mapfn, T, « kValue, k »).
  4. Else, let mappedValue be kValue.
  5. Perform ? Set(targetObj, Pk, mappedValue, true).
  6. Increase k by 1.
6. Assert: values is now an empty List.
7. Return targetObj.
NOTE: source is not an Iterable so assume it is already an array-like object.
Let arrayLike be ! ToObject(source).
Let len be ? ToLength(? Get(arrayLike, "length")).
Let targetObj be ? TypedArrayCreate(C, « len »).
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(arrayLike, Pk).
3. If mapping is true, then
  1. Let mappedValue be ? Call(mapfn, T, « kValue, k »).
4. Else, let mappedValue be kValue.
5. Perform ? Set(targetObj, Pk, mappedValue, true).
6. Increase k by 1.
Return targetObj.

22.2.2.1.1运行时语义: IterableToList( `items`, `method` )

The 抽象操作 IterableToList 执行如下:

Let iteratorRecord be ? GetIterator(items, sync, method).
Let values be a new empty List.
Let next be true.
Repeat, while next is not false
1. Set next to ? IteratorStep(iteratorRecord).
2. If next is not false, then
  1. Let nextValue be ? IteratorValue(next).
  2. Append nextValue to the end of the List values.
Return values.

22.2.2.2%TypedArray%.of ( ...`items` )

When the of method is called with any number of arguments, 执行如下:

Let len be the actual number of arguments passed to this function.
Let items be the List of arguments passed to this function.
Let C be the this value.
If IsConstructor(C) is false, 抛出一个 TypeError 异常.
Let newObj be ? TypedArrayCreate(C, « len »).
Let k be 0.
Repeat, while k < len
1. Let kValue be items[k].
2. Let Pk be ! ToString(k).
3. Perform ? Set(newObj, Pk, kValue, true).
4. Increase k by 1.
Return newObj.

Note

The items argument is assumed to be a well-formed rest argument value.

22.2.2.3%TypedArray%.prototype

The 初始值 of %TypedArray%.prototype is the %TypedArrayPrototype% 内部对象.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

22.2.2.4get %TypedArray% [ @@species ]

%TypedArray%[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

%TypedArrayPrototype% methods normally use their this object's 构造器 to create a derived object. However, a subclass 构造器 may over-ride that default behaviour by redefining its @@species property.

22.2.3Properties of the %TypedArrayPrototype% Object

[[Prototype]] 内部属性的值 of the %TypedArrayPrototype% object is the 内部对象 %ObjectPrototype%. The %TypedArrayPrototype% object is an 普通对象. It does not have a [[ViewedArrayBuffer]] or any other of the 内部属性 that are specific to TypedArray instance objects.

22.2.3.1get %TypedArray%.prototype.buffer

%TypedArray%.prototype.buffer is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
Return buffer.

22.2.3.2get %TypedArray%.prototype.byteLength

%TypedArray%.prototype.byteLength is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, return 0.
Let size be O.[[ByteLength]].
Return size.

22.2.3.3get %TypedArray%.prototype.byteOffset

%TypedArray%.prototype.byteOffset is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, return 0.
Let offset be O.[[ByteOffset]].
Return offset.

22.2.3.4%TypedArray%.prototype.constructor

The 初始值 of %TypedArray%.prototype.构造器 is the %TypedArray% 内部对象.

22.2.3.5%TypedArray%.prototype.copyWithin ( `target`, `start` [ , `end` ] )

The interpretation and use of the arguments of %TypedArray%.prototype.copyWithin are the same as for Array.prototype.copyWithin as defined in 22.1.3.3.

执行如下:

Let O be this value.
Perform ? ValidateTypedArray(O).
Let len be O.[[ArrayLength]].
Let relativeTarget be ? ToInteger(target).
If relativeTarget < 0, let to be max((len + relativeTarget), 0); else let to be min(relativeTarget, len).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let from be max((len + relativeStart), 0); else let from be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let count be min(final-from, len-to).
If count > 0, then
1. NOTE: The copying must be performed in a manner that preserves the bit-level encoding of the source data.
2. Let buffer be O.[[ViewedArrayBuffer]].
3. If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
4. Let typedArrayName be the String 值 of O.[[TypedArrayName]].
5. Let elementSize be the Number 值 of the Element Size value specified in Table 56 for typedArrayName.
6. Let byteOffset be O.[[ByteOffset]].
7. Let toByteIndex be to × elementSize + byteOffset.
8. Let fromByteIndex be from × elementSize + byteOffset.
9. Let countBytes be count × elementSize.
10. If fromByteIndex<toByteIndex and toByteIndex<fromByteIndex+countBytes, then
  1. Let direction be -1.
  2. Let fromByteIndex be fromByteIndex + countBytes - 1.
  3. Let toByteIndex be toByteIndex + countBytes - 1.
11. Else,
  1. Let direction be 1.
12. Repeat, while countBytes > 0
  1. Let value be GetValueFromBuffer(buffer, fromByteIndex, "Uint8", true, "Unordered").
  2. Perform SetValueInBuffer(buffer, toByteIndex, "Uint8", value, true, "Unordered").
  3. Let fromByteIndex be fromByteIndex + direction.
  4. Let toByteIndex be toByteIndex + direction.
  5. Let countBytes be countBytes - 1.
Return O.

22.2.3.5.1运行时语义: ValidateTypedArray ( `O` )

When called with argument O, 执行如下:

If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Return buffer.

22.2.3.6%TypedArray%.prototype.entries ( )

执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Return CreateArrayIterator(O, "key+value").

22.2.3.7%TypedArray%.prototype.every ( `callbackfn` [ , `thisArg` ] )

%TypedArray%.prototype.every is a distinct function that implements the same 算法 as Array.prototype.every as defined in 22.1.3.5 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

This function is not generic. ValidateTypedArray is applied to the this value prior to evaluating the 算法. If its result is an abrupt completion that 异常 is thrown instead of evaluating the 算法.

22.2.3.8%TypedArray%.prototype.fill ( `value` [ , `start` [ , `end` ] ] )

The interpretation and use of the arguments of %TypedArray%.prototype.fill are the same as for Array.prototype.fill as defined in 22.1.3.6.

执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Let len be O.[[ArrayLength]].
Let value be ? ToNumber(value).
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
If IsDetachedBuffer(O.[[ViewedArrayBuffer]]) is true, 抛出一个 TypeError 异常.
Repeat, while k < final
1. Let Pk be ! ToString(k).
2. Perform ! Set(O, Pk, value, true).
3. Increase k by 1.
Return O.

22.2.3.9%TypedArray%.prototype.filter ( `callbackfn` [ , `thisArg` ] )

The interpretation and use of the arguments of %TypedArray%.prototype.filter are the same as for Array.prototype.filter as defined in 22.1.3.7.

When the filter method is called with one or two arguments, 执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Let len be O.[[ArrayLength]].
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let kept be a new empty List.
Let k be 0.
Let captured be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(O, Pk).
3. Let selected be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
4. If selected is true, then
  1. Append kValue to the end of kept.
  2. Increase captured by 1.
5. Increase k by 1.
Let A be ? TypedArraySpeciesCreate(O, « captured »).
Let n be 0.
For each element e of kept, do
1. Perform ! Set(A, ! ToString(n), e, true).
2. Increment n by 1.
Return A.

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.10%TypedArray%.prototype.find ( `predicate` [ , `thisArg` ] )

%TypedArray%.prototype.find is a distinct function that implements the same 算法 as Array.prototype.find as defined in 22.1.3.8 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to predicate may cause the this value to become detached.

22.2.3.11%TypedArray%.prototype.findIndex ( `predicate` [ , `thisArg` ] )

%TypedArray%.prototype.findIndex is a distinct function that implements the same 算法 as Array.prototype.findIndex as defined in 22.1.3.9 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to predicate may cause the this value to become detached.

22.2.3.12%TypedArray%.prototype.forEach ( `callbackfn` [ , `thisArg` ] )

%TypedArray%.prototype.forEach is a distinct function that implements the same 算法 as Array.prototype.forEach as defined in 22.1.3.10 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

22.2.3.13%TypedArray%.prototype.includes ( `searchElement` [ , `fromIndex` ] )

%TypedArray%.prototype.includes is a distinct function that implements the same 算法 as Array.prototype.includes as defined in 22.1.3.11 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

22.2.3.14%TypedArray%.prototype.indexOf ( `searchElement` [ , `fromIndex` ] )

%TypedArray%.prototype.indexOf is a distinct function that implements the same 算法 as Array.prototype.indexOf as defined in 22.1.3.12 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

22.2.3.15%TypedArray%.prototype.join ( `separator` )

%TypedArray%.prototype.join is a distinct function that implements the same 算法 as Array.prototype.join as defined in 22.1.3.13 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

22.2.3.16%TypedArray%.prototype.keys ( )

执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Return CreateArrayIterator(O, "key").

22.2.3.17%TypedArray%.prototype.lastIndexOf ( `searchElement` [ , `fromIndex` ] )

%TypedArray%.prototype.lastIndexOf is a distinct function that implements the same 算法 as Array.prototype.lastIndexOf as defined in 22.1.3.15 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

22.2.3.18get %TypedArray%.prototype.length

%TypedArray%.prototype.length is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has [[ViewedArrayBuffer]] and [[ArrayLength]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, return 0.
Let length be O.[[ArrayLength]].
Return length.

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.19%TypedArray%.prototype.map ( `callbackfn` [ , `thisArg` ] )

The interpretation and use of the arguments of %TypedArray%.prototype.map are the same as for Array.prototype.map as defined in 22.1.3.16.

When the map method is called with one or two arguments, 执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Let len be O.[[ArrayLength]].
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let A be ? TypedArraySpeciesCreate(O, « len »).
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(O, Pk).
3. Let mappedValue be ? Call(callbackfn, T, « kValue, k, O »).
4. Perform ? Set(A, Pk, mappedValue, true).
5. Increase k by 1.
Return A.

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.20%TypedArray%.prototype.reduce ( `callbackfn` [ , `initialValue` ] )

%TypedArray%.prototype.reduce is a distinct function that implements the same 算法 as Array.prototype.reduce as defined in 22.1.3.19 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

22.2.3.21%TypedArray%.prototype.reduceRight ( `callbackfn` [ , `initialValue` ] )

%TypedArray%.prototype.reduceRight is a distinct function that implements the same 算法 as Array.prototype.reduceRight as defined in 22.1.3.20 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

22.2.3.22%TypedArray%.prototype.reverse ( )

%TypedArray%.prototype.reverse is a distinct function that implements the same 算法 as Array.prototype.reverse as defined in 22.1.3.21 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

22.2.3.23%TypedArray%.prototype.set ( `overloaded` [ , `offset` ] )

%TypedArray%.prototype.set is a single function whose behaviour is overloaded based upon the type of its first argument.

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.23.1%TypedArray%.prototype.set ( `array` [ , `offset` ] )

Sets multiple values in this TypedArray, reading the values from the object array. The optional offset value indicates the first element index in this TypedArray where values are written. If omitted, it is assumed to be 0.

Assert: array is any ES 语言值 other than an Object with a [[TypedArrayName]] 内部属性. If it is such an Object, the definition in 22.2.3.23.2 applies.
Let target be the this value.
If Type(target) is not Object, 抛出一个 TypeError 异常.
If target does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: target has a [[ViewedArrayBuffer]] 内部属性.
Let targetOffset be ? ToInteger(offset).
If targetOffset < 0, 抛出一个 RangeError 异常.
Let targetBuffer be target.[[ViewedArrayBuffer]].
If IsDetachedBuffer(targetBuffer) is true, 抛出一个 TypeError 异常.
Let targetLength be target.[[ArrayLength]].
Let targetName be the String 值 of target.[[TypedArrayName]].
Let targetElementSize be the Number 值 of the Element Size value specified in Table 56 for targetName.
Let targetType be the String 值 of the Element Type value in Table 56 for targetName.
Let targetByteOffset be target.[[ByteOffset]].
Let src be ? ToObject(array).
Let srcLength be ? ToLength(? Get(src, "length")).
If srcLength + targetOffset > targetLength, 抛出一个 RangeError 异常.
Let targetByteIndex be targetOffset × targetElementSize + targetByteOffset.
Let k be 0.
Let limit be targetByteIndex + targetElementSize × srcLength.
Repeat, while targetByteIndex < limit
1. Let Pk be ! ToString(k).
2. Let kNumber be ? ToNumber(? Get(src, Pk)).
3. If IsDetachedBuffer(targetBuffer) is true, 抛出一个 TypeError 异常.
4. Perform SetValueInBuffer(targetBuffer, targetByteIndex, targetType, kNumber, true, "Unordered").
5. Set k to k + 1.
6. Set targetByteIndex to targetByteIndex + targetElementSize.
Return undefined.

22.2.3.23.2%TypedArray%.prototype.set( `typedArray` [ , `offset` ] )

Sets multiple values in this TypedArray, reading the values from the typedArray argument object. The optional offset value indicates the first element index in this TypedArray where values are written. If omitted, it is assumed to be 0.

Assert: typedArray has a [[TypedArrayName]] 内部属性. If it does not, the definition in 22.2.3.23.1 applies.
Let target be the this value.
If Type(target) is not Object, 抛出一个 TypeError 异常.
If target does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: target has a [[ViewedArrayBuffer]] 内部属性.
Let targetOffset be ? ToInteger(offset).
If targetOffset < 0, 抛出一个 RangeError 异常.
Let targetBuffer be target.[[ViewedArrayBuffer]].
If IsDetachedBuffer(targetBuffer) is true, 抛出一个 TypeError 异常.
Let targetLength be target.[[ArrayLength]].
Let srcBuffer be typedArray.[[ViewedArrayBuffer]].
If IsDetachedBuffer(srcBuffer) is true, 抛出一个 TypeError 异常.
Let targetName be the String 值 of target.[[TypedArrayName]].
Let targetType be the String 值 of the Element Type value in Table 56 for targetName.
Let targetElementSize be the Number 值 of the Element Size value specified in Table 56 for targetName.
Let targetByteOffset be target.[[ByteOffset]].
Let srcName be the String 值 of typedArray.[[TypedArrayName]].
Let srcType be the String 值 of the Element Type value in Table 56 for srcName.
Let srcElementSize be the Number 值 of the Element Size value specified in Table 56 for srcName.
Let srcLength be typedArray.[[ArrayLength]].
Let srcByteOffset be typedArray.[[ByteOffset]].
If srcLength + targetOffset > targetLength, 抛出一个 RangeError 异常.
If both IsSharedArrayBuffer(srcBuffer) and IsSharedArrayBuffer(targetBuffer) are true, then
1. If srcBuffer.[[ArrayBufferData]] and targetBuffer.[[ArrayBufferData]] are the same 共享数据块 values, let same be true; else let same be false.
Else, let same be SameValue(srcBuffer, targetBuffer).
If same is true, then
1. Let srcByteLength be typedArray.[[ByteLength]].
2. Let srcBuffer be ? CloneArrayBuffer(srcBuffer, srcByteOffset, srcByteLength, %ArrayBuffer%).
3. NOTE: %ArrayBuffer% is used to clone srcBuffer because is it known to not have any observable side-effects.
4. Let srcByteIndex be 0.
Else, let srcByteIndex be srcByteOffset.
Let targetByteIndex be targetOffset × targetElementSize + targetByteOffset.
Let limit be targetByteIndex + targetElementSize × srcLength.
If SameValue(srcType, targetType) is true, then
1. NOTE: If srcType and targetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
2. Repeat, while targetByteIndex < limit
  1. Let value be GetValueFromBuffer(srcBuffer, srcByteIndex, "Uint8", true, "Unordered").
  2. Perform SetValueInBuffer(targetBuffer, targetByteIndex, "Uint8", value, true, "Unordered").
  3. Set srcByteIndex to srcByteIndex + 1.
  4. Set targetByteIndex to targetByteIndex + 1.
Else,
1. Repeat, while targetByteIndex < limit
  1. Let value be GetValueFromBuffer(srcBuffer, srcByteIndex, srcType, true, "Unordered").
  2. Perform SetValueInBuffer(targetBuffer, targetByteIndex, targetType, value, true, "Unordered").
  3. Set srcByteIndex to srcByteIndex + srcElementSize.
  4. Set targetByteIndex to targetByteIndex + targetElementSize.
Return undefined.

22.2.3.24%TypedArray%.prototype.slice ( `start`, `end` )

The interpretation and use of the arguments of %TypedArray%.prototype.slice are the same as for Array.prototype.slice as defined in 22.1.3.23. 执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Let len be O.[[ArrayLength]].
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let k be max((len + relativeStart), 0); else let k be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let count be max(final - k, 0).
Let A be ? TypedArraySpeciesCreate(O, « count »).
Let srcName be the String 值 of O.[[TypedArrayName]].
Let srcType be the String 值 of the Element Type value in Table 56 for srcName.
Let targetName be the String 值 of A.[[TypedArrayName]].
Let targetType be the String 值 of the Element Type value in Table 56 for targetName.
If SameValue(srcType, targetType) is false, then
1. Let n be 0.
2. Repeat, while k < final
  1. Let Pk be ! ToString(k).
  2. Let kValue be ? Get(O, Pk).
  3. Perform ! Set(A, ! ToString(n), kValue).
  4. Increase k by 1.
  5. Increase n by 1.
Else if count > 0, then
1. Let srcBuffer be O.[[ViewedArrayBuffer]].
2. If IsDetachedBuffer(srcBuffer) is true, 抛出一个 TypeError 异常.
3. Let targetBuffer be A.[[ViewedArrayBuffer]].
4. Let elementSize be the Number 值 of the Element Size value specified in Table 56 for srcType.
5. NOTE: If srcType and targetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
6. Let srcByteOffet be O.[[ByteOffset]].
7. Let targetByteIndex be A.[[ByteOffset]].
8. Let srcByteIndex be (k × elementSize) + srcByteOffet.
9. Let limit be targetByteIndex + count × elementSize.
10. Repeat, while targetByteIndex < limit
  1. Let value be GetValueFromBuffer(srcBuffer, srcByteIndex, "Uint8", true, "Unordered").
  2. Perform SetValueInBuffer(targetBuffer, targetByteIndex, "Uint8", value, true, "Unordered").
  3. Increase srcByteIndex by 1.
  4. Increase targetByteIndex by 1.
Return A.

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.25%TypedArray%.prototype.some ( `callbackfn` [ , `thisArg` ] )

%TypedArray%.prototype.some is a distinct function that implements the same 算法 as Array.prototype.some as defined in 22.1.3.24 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法 and must take into account the possibility that calls to callbackfn may cause the this value to become detached.

22.2.3.26%TypedArray%.prototype.sort ( `comparefn` )

%TypedArray%.prototype.sort is a distinct function that, except as described below, implements the same requirements as those of Array.prototype.sort as defined in 22.1.3.25. The 实现 of the %TypedArray%.prototype.sort specification may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. The only 内部方法 of the this object that the 算法 may call are [[Get]] and [[Set]].

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

Upon entry, the following steps are performed to initialize 估值 of the sort function. These steps are used instead of the entry steps in 22.1.3.25:

If comparefn is not undefined and IsCallable(comparefn) is false, 抛出一个 TypeError 异常.
Let obj be the this value.
Let buffer be ? ValidateTypedArray(obj).
Let len be obj.[[ArrayLength]].

The 实现-defined sort order condition for 外来对象 is not applied by %TypedArray%.prototype.sort.

The following version of SortCompare is used by %TypedArray%.prototype.sort. It performs a numeric comparison rather than the string comparison used in 22.1.3.25. SortCompare has access to the comparefn and buffer values of the current invocation of the sort method.

When the TypedArray SortCompare 抽象操作 is called with two arguments x and y, 执行如下:

Assert: Both Type(x) and Type(y) is Number.
If comparefn is not undefined, then
1. Let v be ? ToNumber(? Call(comparefn, undefined, « x, y »)).
2. If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
3. If v is NaN, return +0.
4. Return v.
If x and y are both NaN, return +0.
If x is NaN, return 1.
If y is NaN, return -1.
If x < y, return -1.
If x > y, return 1.
If x is -0 and y is +0, return -1.
If x is +0 and y is -0, return 1.
Return +0.

Note

Because NaN always compares greater than any other value, NaN property values always sort to the end of the result when comparefn is not provided.

22.2.3.27%TypedArray%.prototype.subarray( `begin`, `end` )

Returns a new TypedArray object whose element type is the same as this TypedArray and whose ArrayBuffer is the same as the ArrayBuffer of this TypedArray, referencing the elements at begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
Let srcLength be O.[[ArrayLength]].
Let relativeBegin be ? ToInteger(begin).
If relativeBegin < 0, let beginIndex be max((srcLength + relativeBegin), 0); else let beginIndex be min(relativeBegin, srcLength).
If end is undefined, let relativeEnd be srcLength; else, let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let endIndex be max((srcLength + relativeEnd), 0); else let endIndex be min(relativeEnd, srcLength).
Let newLength be max(endIndex - beginIndex, 0).
Let constructorName be the String 值 of O.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for constructorName.
Let srcByteOffset be O.[[ByteOffset]].
Let beginByteOffset be srcByteOffset + beginIndex × elementSize.
Let argumentsList be « buffer, beginByteOffset, newLength ».
Return ? TypedArraySpeciesCreate(O, argumentsList).

This function is not generic. The this value must be an object with a [[TypedArrayName]] 内部属性.

22.2.3.28%TypedArray%.prototype.toLocaleString ( [ `reserved1` [ , `reserved2` ] ] )

%TypedArray%.prototype.toLocaleString is a distinct function that implements the same 算法 as Array.prototype.toLocaleString as defined in 22.1.3.27 except that the this object's [[ArrayLength]] 内部属性 is accessed in place of performing a [[Get]] of "length". The 实现 of the 算法 may be optimized with the knowledge that the this value is an object that has a fixed length and whose integer-indexed properties are not sparse. However, such optimization must not introduce any observable changes in the specified behaviour of the 算法.

Note

If the ES 实现 includes the ECMA-402 Internationalization API this function is based upon the 算法 for Array.prototype.toLocaleString that is in the ECMA-402 specification.

22.2.3.29%TypedArray%.prototype.toString ( )

The 初始值 of the %TypedArray%.prototype.toString 数据属性 is the same 内置函数对象 as the Array.prototype.toString method defined in 22.1.3.28.

22.2.3.30%TypedArray%.prototype.values ( )

执行如下:

Let O be the this value.
Perform ? ValidateTypedArray(O).
Return CreateArrayIterator(O, "value").

22.2.3.31%TypedArray%.prototype [ @@迭代器 ] ( )

The 初始值 of the @@迭代器 property is the same 函数对象 as the 初始值 of the %TypedArray%.prototype.values property.

22.2.3.32get %TypedArray%.prototype [ @@toStringTag ]

%TypedArray%.prototype[@@toStringTag] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, return undefined.
If O does not have a [[TypedArrayName]] 内部属性, return undefined.
Let name be O.[[TypedArrayName]].
Assert: name is a String 值.
Return name.

该属性拥有特性 { [[Enumerable]]: false, [[Configurable]]: true }.

The 初始值 of the name property of this function is "get [Symbol.toStringTag]".

22.2.4The `TypedArray` Constructors

Each of the TypedArray 构造器 objects is an 内部对象 that has the structure described below, differing only in the name used as the 构造器 name instead of TypedArray, in Table 56.

The TypedArray intrinsic 构造器 functions are single functions whose behaviour is overloaded based upon the number and types of its arguments. The actual behaviour of a call of TypedArray depends upon the number and kind of arguments that are passed to it.

The TypedArray constructors are not intended to be called as a function and will 抛出一个异常 when called in that manner.

The TypedArray constructors are designed to be subclassable. They may be used as the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 TypedArray behaviour must include a super call to the TypedArray 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the %TypedArray%.prototype 内置方法.

The length property of the TypedArray 构造器 function is 3.

22.2.4.1`TypedArray` ( )

This description applies only if the TypedArray function is called with no arguments.

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let constructorName be the String 值 of the 构造器 Name value specified in Table 56 for this TypedArray 构造器.
Return ? AllocateTypedArray(constructorName, NewTarget, "%TypedArrayPrototype%", 0).

22.2.4.2`TypedArray` ( `length` )

This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is not Object.

TypedArray called with argument length 执行如下:

Assert: Type(length) is not Object.
If NewTarget is undefined, 抛出一个 TypeError 异常.
Let elementLength be ? ToIndex(length).
Let constructorName be the String 值 of the 构造器 Name value specified in Table 56 for this TypedArray 构造器.
Return ? AllocateTypedArray(constructorName, NewTarget, "%TypedArrayPrototype%", elementLength).

22.2.4.2.1运行时语义: AllocateTypedArray ( `constructorName`, `newTarget`, `defaultProto` [ , `length` ] )

The 抽象操作 AllocateTypedArray with arguments constructorName, newTarget, defaultProto and 可选参数 length is used to validate and create an instance of a TypedArray 构造器. constructorName is required to be the name of a TypedArray 构造器 in Table 56. If the length argument is passed, an ArrayBuffer of that length is also allocated and associated with the new TypedArray instance. AllocateTypedArray provides common 语义 that is used by all of the TypedArray overloads. AllocateTypedArray 执行如下:

Let proto be ? GetPrototypeFromConstructor(newTarget, defaultProto).
Let obj be IntegerIndexedObjectCreate(proto, « [[ViewedArrayBuffer]], [[TypedArrayName]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] »).
Assert: obj.[[ViewedArrayBuffer]] is undefined.
Set obj.[[TypedArrayName]] to constructorName.
If length is not present, then
1. Set obj.[[ByteLength]] to 0.
2. Set obj.[[ByteOffset]] to 0.
3. Set obj.[[ArrayLength]] to 0.
Else,
1. Perform ? AllocateTypedArrayBuffer(obj, length).
Return obj.

22.2.4.2.2运行时语义: AllocateTypedArrayBuffer ( `O`, `length` )

The 抽象操作 AllocateTypedArrayBuffer with arguments O and length allocates and associates an ArrayBuffer with the TypedArray instance O. It 执行如下:

Assert: O is an Object that has a [[ViewedArrayBuffer]] 内部属性.
Assert: O.[[ViewedArrayBuffer]] is undefined.
Assert: length ≥ 0.
Let constructorName be the String 值 of O.[[TypedArrayName]].
Let elementSize be the Element Size value in Table 56 for constructorName.
Let byteLength be elementSize × length.
Let data be ? AllocateArrayBuffer(%ArrayBuffer%, byteLength).
Set O.[[ViewedArrayBuffer]] to data.
Set O.[[ByteLength]] to byteLength.
Set O.[[ByteOffset]] to 0.
Set O.[[ArrayLength]] to length.
Return O.

22.2.4.3`TypedArray` ( `typedArray` )

This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object has a [[TypedArrayName]] 内部属性.

TypedArray called with argument typedArray 执行如下:

Assert: Type(typedArray) is Object and typedArray has a [[TypedArrayName]] 内部属性.
If NewTarget is undefined, 抛出一个 TypeError 异常.
Let constructorName be the String 值 of the 构造器 Name value specified in Table 56 for this TypedArray 构造器.
Let O be ? AllocateTypedArray(constructorName, NewTarget, "%TypedArrayPrototype%").
Let srcArray be typedArray.
Let srcData be srcArray.[[ViewedArrayBuffer]].
If IsDetachedBuffer(srcData) is true, 抛出一个 TypeError 异常.
Let elementType be the String 值 of the Element Type value in Table 56 for constructorName.
Let elementLength be srcArray.[[ArrayLength]].
Let srcName be the String 值 of srcArray.[[TypedArrayName]].
Let srcType be the String 值 of the Element Type value in Table 56 for srcName.
Let srcElementSize be the Element Size value in Table 56 for srcName.
Let srcByteOffset be srcArray.[[ByteOffset]].
Let elementSize be the Element Size value in Table 56 for constructorName.
Let byteLength be elementSize × elementLength.
If IsSharedArrayBuffer(srcData) is false, then
1. Let bufferConstructor be ? SpeciesConstructor(srcData, %ArrayBuffer%).
Else,
1. Let bufferConstructor be %ArrayBuffer%.
If SameValue(elementType, srcType) is true, then
1. If IsDetachedBuffer(srcData) is true, 抛出一个 TypeError 异常.
2. Let data be ? CloneArrayBuffer(srcData, srcByteOffset, byteLength, bufferConstructor).
Else,
1. Let data be ? AllocateArrayBuffer(bufferConstructor, byteLength).
2. If IsDetachedBuffer(srcData) is true, 抛出一个 TypeError 异常.
3. Let srcByteIndex be srcByteOffset.
4. Let targetByteIndex be 0.
5. Let count be elementLength.
6. Repeat, while count > 0
  1. Let value be GetValueFromBuffer(srcData, srcByteIndex, srcType, true, "Unordered").
  2. Perform SetValueInBuffer(data, targetByteIndex, elementType, value, true, "Unordered").
  3. Set srcByteIndex to srcByteIndex + srcElementSize.
  4. Set targetByteIndex to targetByteIndex + elementSize.
  5. Decrement count by 1.
Set O.[[ViewedArrayBuffer]] to data.
Set O.[[ByteLength]] to byteLength.
Set O.[[ByteOffset]] to 0.
Set O.[[ArrayLength]] to elementLength.
Return O.

22.2.4.4`TypedArray` ( `object` )

This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] 内部属性.

TypedArray called with argument object 执行如下:

Assert: Type(object) is Object and object does not have either a [[TypedArrayName]] or an [[ArrayBufferData]] 内部属性.
If NewTarget is undefined, 抛出一个 TypeError 异常.
Let constructorName be the String 值 of the 构造器 Name value specified in Table 56 for this TypedArray 构造器.
Let O be ? AllocateTypedArray(constructorName, NewTarget, "%TypedArrayPrototype%").
Let usingIterator be ? GetMethod(object, @@迭代器).
If usingIterator is not undefined, then
1. Let values be ? IterableToList(object, usingIterator).
2. Let len be the number of elements in values.
3. Perform ? AllocateTypedArrayBuffer(O, len).
4. Let k be 0.
5. Repeat, while k < len
  1. Let Pk be ! ToString(k).
  2. Let kValue be the first element of values and remove that element from values.
  3. Perform ? Set(O, Pk, kValue, true).
  4. Increase k by 1.
6. Assert: values is now an empty List.
7. Return O.
NOTE: object is not an Iterable so assume it is already an array-like object.
Let arrayLike be object.
Let len be ? ToLength(? Get(arrayLike, "length")).
Perform ? AllocateTypedArrayBuffer(O, len).
Let k be 0.
Repeat, while k < len
1. Let Pk be ! ToString(k).
2. Let kValue be ? Get(arrayLike, Pk).
3. Perform ? Set(O, Pk, kValue, true).
4. Increase k by 1.
Return O.

22.2.4.5`TypedArray` ( `buffer` [ , `byteOffset` [ , `length` ] ] )

This description applies only if the TypedArray function is called with at least one argument and the Type of the first argument is Object and that object has an [[ArrayBufferData]] 内部属性.

TypedArray called with at least one argument buffer 执行如下:

Assert: Type(buffer) is Object and buffer has an [[ArrayBufferData]] 内部属性.
If NewTarget is undefined, 抛出一个 TypeError 异常.
Let constructorName be the String 值 of the 构造器 Name value specified in Table 56 for this TypedArray 构造器.
Let O be ? AllocateTypedArray(constructorName, NewTarget, "%TypedArrayPrototype%").
Let elementSize be the Number 值 of the Element Size value in Table 56 for constructorName.
Let offset be ? ToIndex(byteOffset).
If offset modulo elementSize ≠ 0, 抛出一个 RangeError 异常.
If length is present and length is not undefined, then
1. Let newLength be ? ToIndex(length).
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let bufferByteLength be buffer.[[ArrayBufferByteLength]].
If length is either not present or undefined, then
1. If bufferByteLength modulo elementSize ≠ 0, 抛出一个 RangeError 异常.
2. Let newByteLength be bufferByteLength - offset.
3. If newByteLength < 0, 抛出一个 RangeError 异常.
Else,
1. Let newByteLength be newLength × elementSize.
2. If offset+newByteLength > bufferByteLength, 抛出一个 RangeError 异常.
Set O.[[ViewedArrayBuffer]] to buffer.
Set O.[[ByteLength]] to newByteLength.
Set O.[[ByteOffset]] to offset.
Set O.[[ArrayLength]] to newByteLength / elementSize.
Return O.

22.2.4.6TypedArrayCreate ( `构造器`, `argumentList` )

The 抽象操作 TypedArrayCreate with arguments 构造器 and argumentList is used to specify the creation of a new TypedArray object using a 构造器 function. It 执行如下:

Let newTypedArray be ? Construct(构造器, argumentList).
Perform ? ValidateTypedArray(newTypedArray).
If argumentList is a List of a single Number, then
1. If newTypedArray.[[ArrayLength]] < argumentList[0], 抛出一个 TypeError 异常.
Return newTypedArray.

22.2.4.7TypedArraySpeciesCreate ( `exemplar`, `argumentList` )

The 抽象操作 TypedArraySpeciesCreate with arguments exemplar and argumentList is used to specify the creation of a new TypedArray object using a 构造器 function that is derived from exemplar. It 执行如下:

Assert: exemplar is an Object that has a [[TypedArrayName]] 内部属性.
Let defaultConstructor be the 内部对象 listed in column one of Table 56 for exemplar.[[TypedArrayName]].
Let 构造器 be ? SpeciesConstructor(exemplar, defaultConstructor).
Return ? TypedArrayCreate(构造器, argumentList).

22.2.5Properties of the `TypedArray` Constructors

[[Prototype]] 内部属性的值 of each TypedArray 构造器 is the %TypedArray% 内部对象.

Each TypedArray 构造器 has a name property whose value is the String 值 of the 构造器 name specified for it in Table 56.

Each TypedArray 构造器有以下属性:

22.2.5.1`TypedArray`.BYTES_PER_ELEMENT

The value of TypedArray.BYTES_PER_ELEMENT is the Number 值 of the Element Size value specified in Table 56 for TypedArray.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

22.2.5.2`TypedArray`.prototype

The 初始值 of TypedArray.prototype is the corresponding TypedArray prototype 内部对象 (22.2.6).

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

22.2.6Properties of `TypedArray` Prototype Objects

[[Prototype]] 内部属性的值 of a TypedArray 原型对象 is the 内部对象 %TypedArrayPrototype%. A TypedArray 原型对象 is an 普通对象. It does not have a [[ViewedArrayBuffer]] or any other of the 内部属性 that are specific to TypedArray instance objects.

22.2.6.1`TypedArray`.prototype.BYTES_PER_ELEMENT

The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Number 值 of the Element Size value specified in Table 56 for TypedArray.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

22.2.6.2`TypedArray`.prototype.constructor

The 初始值 of a TypedArray.prototype.constructor is the corresponding %TypedArray% 内部对象.

22.2.7Properties of `TypedArray` Instances

TypedArray instances are Integer-Indexed 外来对象. Each TypedArray instance inherits properties from the corresponding TypedArray 原型对象. Each TypedArray instance has the following 内部属性: [[TypedArrayName]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]], and [[ArrayLength]].

23键集合

23.1Map 对象

Map 对象 are collections of key/value pairs where both the keys and values may be arbitrary ES 语言值. A distinct key value may only occur in one key/value pair within the Map's collection. Distinct key values are discriminated using the SameValueZero 比较算法.

Map object must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The 数据结构 used in this Map 对象 specification is only intended to describe the required observable 语义 of Map 对象. It is not intended to be a viable 实现 model.

23.1.1Map 构造器

The Map 构造器 is the %Map% 内部对象 and the 初始值 of the Map property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 Map object. Map is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The Map 构造器被设计成可被子类化的. 它可以用作 the value in an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Map behaviour must include a super call to the Map 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the Map.prototype 内置方法.

23.1.1.1Map ( [ `iterable` ] )

When the Map function is called with 可选参数, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%MapPrototype%", « [[MapData]] »).
Set map.[[MapData]] to a new empty List.
If iterable is not present, let iterable be undefined.
If iterable is either undefined or null, return map.
Let adder be ? Get(map, "set").
If IsCallable(adder) is false, 抛出一个 TypeError 异常.
Let iteratorRecord be ? GetIterator(iterable).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return map.
3. Let nextItem be ? IteratorValue(next).
4. If Type(nextItem) is not Object, then
  1. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
  2. Return ? IteratorClose(iteratorRecord, error).
5. Let k be Get(nextItem, "0").
6. If k is an abrupt completion, return ? IteratorClose(iteratorRecord, k).
7. Let v be Get(nextItem, "1").
8. If v is an abrupt completion, return ? IteratorClose(iteratorRecord, v).
9. Let status be Call(adder, map, « k.[[Value]], v.[[Value]] »).
10. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).

Note

If the parameter iterable is present, it is expected to be an object that implements an @@迭代器 method that returns an 迭代器 object that produces a two element array-like object whose first element is a value that will be used as a Map key and whose second element is the value to associate with that key.

23.1.2Map 构造器的属性

[[Prototype]] 内部属性的值 of the Map 构造器 is the 内部对象 %FunctionPrototype%.

The Map 构造器有以下属性:

23.1.2.1Map.prototype

The 初始值 of Map.prototype is the 内部对象 %MapPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

23.1.2.2get Map [ @@species ]

Map[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

Methods that create derived collection objects should call @@species to determine the 构造器 to use to create the derived objects. Subclass 构造器 may over-ride @@species to change the default 构造器 assignment.

23.1.3Map 原型对象的属性

The Map 原型对象 is the 内部对象 %MapPrototype%. [[Prototype]] 内部属性的值 of the Map 原型对象 is the 内部对象 %ObjectPrototype%. The Map 原型对象 is an 普通对象. It does not have a [[MapData]] 内部属性.

23.1.3.1Map.prototype.clear ( )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. Set p.[[Key]] to empty.
2. Set p.[[Value]] to empty.
Return undefined.

Note

The existing [[MapData]] List is preserved because there may be existing Map 迭代器对象 that are suspended midway through iterating over that List.

23.1.3.2Map.prototype.constructor

The 初始值 of Map.prototype.constructor is the 内部对象 %Map%.

23.1.3.3Map.prototype.delete ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
  1. Set p.[[Key]] to empty.
  2. Set p.[[Value]] to empty.
  3. Return true.
Return false.

Note

The value empty is used as a specification device to indicate that an entry has been deleted. Actual implementations may take other actions 例如 physically removing the entry from internal 数据结构.

23.1.3.4Map.prototype.entries ( )

执行如下:

Let M be the this value.
Return ? CreateMapIterator(M, "key+value").

23.1.3.5Map.prototype.forEach ( `callbackfn` [ , `thisArg` ] )

When the forEach method is called with one or two arguments, 执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} e that is an element of entries, in original key insertion order, do
1. If e.[[Key]] is not empty, then
  1. Perform ? Call(callbackfn, T, « e.[[Value]], e.[[Key]], M »).
Return undefined.

Note

callbackfn should be a function that accepts three arguments. forEach calls callbackfn once for each key/value pair present in the map object, in key insertion order. callbackfn is called only for keys of the map which actually exist; it is not called for keys that have been deleted from the map.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the value of the item, the key of the item, and the Map object being traversed.

forEach does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn. Each entry of a map's [[MapData]] is only visited once. New keys added after the call to forEach begins are visited. A key will be revisited if it is deleted after it has been visited and then re-added before the forEach call completes. Keys that are deleted after the call to forEach begins and before being visited are not visited unless the key is added again before the forEach call completes.

23.1.3.6Map.prototype.get ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return p.[[Value]].
Return undefined.

23.1.3.7Map.prototype.has ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, return true.
Return false.

23.1.3.8Map.prototype.keys ( )

执行如下:

Let M be the this value.
Return ? CreateMapIterator(M, "key").

23.1.3.9Map.prototype.set ( `key`, `value` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValueZero(p.[[Key]], key) is true, then
  1. Set p.[[Value]] to value.
  2. Return M.
If key is -0, let key be +0.
Let p be the Record {[[Key]]: key, [[Value]]: value}.
Append p as the last element of entries.
Return M.

23.1.3.10get Map.prototype.size

Map.prototype.size is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[MapData]].
Let count be 0.
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty, set count to count+1.
Return count.

23.1.3.11Map.prototype.values ( )

执行如下:

Let M be the this value.
Return ? CreateMapIterator(M, "value").

23.1.3.12Map.prototype [ @@迭代器 ] ( )

The 初始值 of the @@迭代器 property is the same 函数对象 as the 初始值 of the entries property.

23.1.3.13Map.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Map".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.1.4Map 实例的属性

Map instances are 普通对象 that 继承属性 from the Map prototype. Map instances also have a [[MapData]] 内部属性.

23.1.5Map 迭代器对象

A Map 迭代器 is an object, that represents a specific iteration over some specific Map instance object. There is not a named 构造器 for Map 迭代器对象. Instead, Map 迭代器对象 are created by calling certain methods of Map instance objects.

23.1.5.1CreateMapIterator ( `map`, `kind` )

Several methods of Map 对象 return 迭代器对象. The 抽象操作 CreateMapIterator with arguments map and kind is used to create such 迭代器对象. It 执行如下:

If Type(map) is not Object, 抛出一个 TypeError 异常.
If map does not have a [[MapData]] 内部属性, 抛出一个 TypeError 异常.
Let 迭代器 be ObjectCreate(%MapIteratorPrototype%, « [[Map]], [[MapNextIndex]], [[MapIterationKind]] »).
Set 迭代器.[[Map]] to map.
Set 迭代器.[[MapNextIndex]] to 0.
Set 迭代器.[[MapIterationKind]] to kind.
Return 迭代器.

23.1.5.2The %MapIteratorPrototype% Object

All Map 迭代器对象继承属性 from the %MapIteratorPrototype% 内部对象. The %MapIteratorPrototype% 内部对象 is an 普通对象 and its [[Prototype]] 内部属性 is the %IteratorPrototype% 内部对象. In addition, %MapIteratorPrototype% 有以下属性:

23.1.5.2.1%MapIteratorPrototype%.next ( )

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have all of the 内部属性 of a Map 迭代器 Instance (23.1.5.3), 抛出一个 TypeError 异常.
Let m be O.[[Map]].
Let index be O.[[MapNextIndex]].
Let itemKind be O.[[MapIterationKind]].
If m is undefined, return CreateIterResultObject(undefined, true).
Assert: m has a [[MapData]] 内部属性.
Let entries be the List that is m.[[MapData]].
Let numEntries be the number of elements of entries.
NOTE: numEntries must be redetermined each time this method is evaluated.
Repeat, while index is less than numEntries,
1. Let e be the Record {[[Key]], [[Value]]} that is the value of entries[index].
2. Set index to index+1.
3. Set O.[[MapNextIndex]] to index.
4. If e.[[Key]] is not empty, then
  1. If itemKind is "key", let result be e.[[Key]].
  2. Else if itemKind is "value", let result be e.[[Value]].
  3. Else,
    1. Assert: itemKind is "key+value".
    2. Let result be CreateArrayFromList(« e.[[Key]], e.[[Value]] »).
  4. Return CreateIterResultObject(result, false).
Set O.[[Map]] to undefined.
Return CreateIterResultObject(undefined, true).

23.1.5.2.2%MapIteratorPrototype% [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Map 迭代器".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.1.5.3Map 迭代器实例的属性

Map 迭代器实例 are 普通对象 that 继承属性 from the %MapIteratorPrototype% 内部对象. Map 迭代器实例 are initially created with the 内部属性 described in Table 57.

Table 57: 内部属性 of Map 迭代器实例

内部属性	Description
[[Map]]	The Map object that is being iterated.
[[MapNextIndex]]	The 整数索引 of the next Map data element to be examined by this 迭代器.
[[MapIterationKind]]	A String 值 that identifies what is to be returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`.

23.2Set 对象

Set 对象 are collections of ES 语言值. A distinct value may only occur once as an element of a Set's collection. Distinct values are discriminated using the SameValueZero 比较算法.

Set 对象 must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The 数据结构 used in this Set 对象 specification is only intended to describe the required observable 语义 of Set 对象. It is not intended to be a viable 实现 model.

23.2.1Set 构造器

The Set 构造器 is the %Set% 内部对象 and the 初始值 of the Set property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 Set object. Set is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The Set 构造器被设计成可被子类化的. 它可以用作 the value in an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Set behaviour must include a super call to the Set 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the Set.prototype 内置方法.

23.2.1.1Set ( [ `iterable` ] )

When the Set function is called with 可选参数 iterable, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%SetPrototype%", « [[SetData]] »).
Set set.[[SetData]] to a new empty List.
If iterable is not present, let iterable be undefined.
If iterable is either undefined or null, return set.
Let adder be ? Get(set, "add").
If IsCallable(adder) is false, 抛出一个 TypeError 异常.
Let iteratorRecord be ? GetIterator(iterable).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return set.
3. Let nextValue be ? IteratorValue(next).
4. Let status be Call(adder, set, « nextValue.[[Value]] »).
5. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).

23.2.2Set 构造器的属性

[[Prototype]] 内部属性的值 of the Set 构造器 is the 内部对象 %FunctionPrototype%.

The Set 构造器有以下属性:

23.2.2.1Set.prototype

The 初始值 of Set.prototype is the intrinsic %SetPrototype% object.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

23.2.2.2get Set [ @@species ]

Set[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

23.2.3Set 原型对象的属性

The Set 原型对象 is the 内部对象 %SetPrototype%. [[Prototype]] 内部属性的值 of the Set 原型对象 is the 内部对象 %ObjectPrototype%. The Set 原型对象 is an 普通对象. It does not have a [[SetData]] 内部属性.

23.2.3.1Set.prototype.add ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[SetData]].
For each e that is an element of entries, do
1. If e is not empty and SameValueZero(e, value) is true, then
  1. Return S.
If value is -0, let value be +0.
Append value as the last element of entries.
Return S.

23.2.3.2Set.prototype.clear ( )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[SetData]].
For each e that is an element of entries, do
1. Replace the element of entries whose value is e with an element whose value is empty.
Return undefined.

Note

The existing [[SetData]] List is preserved because there may be existing Set 迭代器对象 that are suspended midway through iterating over that List.

23.2.3.3Set.prototype.constructor

The 初始值 of Set.prototype.constructor is the 内部对象 %Set%.

23.2.3.4Set.prototype.delete ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[SetData]].
For each e that is an element of entries, do
1. If e is not empty and SameValueZero(e, value) is true, then
  1. Replace the element of entries whose value is e with an element whose value is empty.
  2. Return true.
Return false.

Note

23.2.3.5Set.prototype.entries ( )

执行如下:

Let S be the this value.
Return ? CreateSetIterator(S, "key+value").

Note

For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.

23.2.3.6Set.prototype.forEach ( `callbackfn` [ , `thisArg` ] )

When the forEach method is called with one or two arguments, 执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
If IsCallable(callbackfn) is false, 抛出一个 TypeError 异常.
If thisArg is present, let T be thisArg; else let T be undefined.
Let entries be the List that is S.[[SetData]].
For each e that is an element of entries, in original insertion order, do
1. If e is not empty, then
  1. Perform ? Call(callbackfn, T, « e, e, S »).
Return undefined.

Note

callbackfn should be a function that accepts three arguments. forEach calls callbackfn once for each value present in the set object, in value insertion order. callbackfn is called only for values of the Set which actually exist; it is not called for keys that have been deleted from the set.

If a thisArg parameter is provided, it will be used as the this value for each invocation of callbackfn. If it is not provided, undefined is used instead.

callbackfn is called with three arguments: the first two arguments are a value contained in the Set. The same value is passed for both arguments. The Set object being traversed is passed as the third argument.

The callbackfn is called with three arguments to be consistent with the call back functions used by forEach methods for Map and Array. For Sets, each item value is considered to be both the key and the value.

forEach does not directly mutate the object on which it is called but the object may be mutated by the calls to callbackfn.

Each value is normally visited only once. However, a value will be revisited if it is deleted after it has been visited and then re-added before the forEach call completes. Values that are deleted after the call to forEach begins and before being visited are not visited unless the value is added again before the forEach call completes. New values added after the call to forEach begins are visited.

23.2.3.7Set.prototype.has ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[SetData]].
For each e that is an element of entries, do
1. If e is not empty and SameValueZero(e, value) is true, return true.
Return false.

23.2.3.8Set.prototype.keys ( )

The 初始值 of the keys property is the same 函数对象 as the 初始值 of the values property.

Note

For iteration purposes, a Set appears similar to a Map where each entry has the same value for its key and value.

23.2.3.9get Set.prototype.size

Set.prototype.size is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[SetData]].
Let count be 0.
For each e that is an element of entries, do
1. If e is not empty, set count to count+1.
Return count.

23.2.3.10Set.prototype.values ( )

执行如下:

Let S be the this value.
Return ? CreateSetIterator(S, "value").

23.2.3.11Set.prototype [ @@迭代器 ] ( )

The 初始值 of the @@迭代器 property is the same 函数对象 as the 初始值 of the values property.

23.2.3.12Set.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Set".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.2.4Set 实例的属性

Set instances are 普通对象 that 继承属性 from the Set prototype. Set instances also have a [[SetData]] 内部属性.

23.2.5Set 迭代器对象

A Set 迭代器 is an 普通对象, with the structure defined below, that represents a specific iteration over some specific Set instance object. There is not a named 构造器 for Set 迭代器对象. Instead, Set 迭代器对象 are created by calling certain methods of Set instance objects.

23.2.5.1CreateSetIterator ( `set`, `kind` )

Several methods of Set 对象 return 迭代器对象. The 抽象操作 CreateSetIterator with arguments set and kind is used to create such 迭代器对象. It 执行如下:

If Type(set) is not Object, 抛出一个 TypeError 异常.
If set does not have a [[SetData]] 内部属性, 抛出一个 TypeError 异常.
Let 迭代器 be ObjectCreate(%SetIteratorPrototype%, « [[IteratedSet]], [[SetNextIndex]], [[SetIterationKind]] »).
Set 迭代器.[[IteratedSet]] to set.
Set 迭代器.[[SetNextIndex]] to 0.
Set 迭代器.[[SetIterationKind]] to kind.
Return 迭代器.

23.2.5.2The %SetIteratorPrototype% Object

All Set 迭代器对象继承属性 from the %SetIteratorPrototype% 内部对象. The %SetIteratorPrototype% 内部对象 is an 普通对象 and its [[Prototype]] 内部属性 is the %IteratorPrototype% 内部对象. In addition, %SetIteratorPrototype% 有以下属性:

23.2.5.2.1%SetIteratorPrototype%.next ( )

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have all of the 内部属性 of a Set 迭代器 Instance (23.2.5.3), 抛出一个 TypeError 异常.
Let s be O.[[IteratedSet]].
Let index be O.[[SetNextIndex]].
Let itemKind be O.[[SetIterationKind]].
If s is undefined, return CreateIterResultObject(undefined, true).
Assert: s has a [[SetData]] 内部属性.
Let entries be the List that is s.[[SetData]].
Let numEntries be the number of elements of entries.
NOTE: numEntries must be redetermined each time this method is evaluated.
Repeat, while index is less than numEntries,
1. Let e be entries[index].
2. Set index to index+1.
3. Set O.[[SetNextIndex]] to index.
4. If e is not empty, then
  1. If itemKind is "key+value", then
    1. Return CreateIterResultObject(CreateArrayFromList(« e, e »), false).
  2. Return CreateIterResultObject(e, false).
Set O.[[IteratedSet]] to undefined.
Return CreateIterResultObject(undefined, true).

23.2.5.2.2%SetIteratorPrototype% [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Set 迭代器".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.2.5.3Set 迭代器实例的属性

Set 迭代器实例 are 普通对象 that 继承属性 from the %SetIteratorPrototype% 内部对象. Set 迭代器实例 are initially created with the 内部属性 specified in Table 58.

Table 58: 内部属性 of Set 迭代器实例

内部属性	Description
[[IteratedSet]]	The Set object that is being iterated.
[[SetNextIndex]]	The 整数索引 of the next Set data element to be examined by this 迭代器
[[SetIterationKind]]	A String 值 that identifies what is to be returned for each element of the iteration. The possible values are: `"key"`, `"value"`, `"key+value"`. `"key"` and `"value"` have the same meaning.

23.3WeakMap 对象

WeakMap 对象 are collections of key/value pairs where the keys are objects and values may be arbitrary ES 语言值. A WeakMap may be queried to see if it contains a key/value pair with a specific key, but no mechanism is provided for enumerating the objects it holds as keys. If an object that is being used as the key of a WeakMap key/value pair is only reachable by following a chain of references that start within that WeakMap, then that key/value pair is inaccessible and is automatically removed from the WeakMap. WeakMap implementations must detect and remove such key/value pairs and any associated resources.

An 实现 may impose an arbitrarily determined latency between the time a key/value pair of a WeakMap becomes inaccessible and the time when the key/value pair is removed from the WeakMap. If this latency was observable to ES 程序, it would be a source of indeterminacy that could impact program execution. For that reason, an ES 实现 must not provide any means to observe a key of a WeakMap that does not require the observer to present the observed key.

WeakMap 对象 must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of key/value pairs in the collection. The data structure used in this WeakMap 对象 specification are only intended to describe the required observable 语义 of WeakMap 对象. It is not intended to be a viable 实现 model.

Note

WeakMap and WeakSets are intended to provide mechanisms for dynamically associating state with an object in a manner that does not “leak” memory resources if, in the absence of the WeakMap or WeakSet, the object otherwise became inaccessible and subject to resource reclamation by the 实现's garbage collection mechanisms. This characteristic can be achieved by using an inverted per-object mapping of weak map instances to keys. Alternatively each weak map may internally store its key to value mappings but this approach requires coordination between the WeakMap or WeakSet 实现 and the garbage collector. The following references describe mechanism that may be useful to implementations of WeakMap and WeakSets:

Barry Hayes. 1997. Ephemerons: a new finalization mechanism. In Proceedings of the 12th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA '97), A. Michael Berman (Ed.). ACM, New York, NY, USA, 176-183, http://doi.acm.org/10.1145/263698.263733.

Alexandra Barros, Roberto Ierusalimschy, Eliminating Cycles in Weak Tables. Journal of Universal Computer Science - J.UCS, vol. 14, no. 21, pp. 3481-3497, 2008, http://www.jucs.org/jucs_14_21/eliminating_cycles_in_weak

23.3.1The WeakMap 构造器

The WeakMap 构造器 is the %WeakMap% 内部对象 and the 初始值 of the WeakMap property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 WeakMap object. WeakMap is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The WeakMap 构造器被设计成可被子类化的. 它可以用作 the value in an extends clause of a class definition. 子类构造器 that 旨在继承特定的 WeakMap behaviour must include a super call to the WeakMap 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the WeakMap.prototype 内置方法.

23.3.1.1WeakMap ( [ `iterable` ] )

When the WeakMap function is called with 可选参数 iterable, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let map be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakMapPrototype%", « [[WeakMapData]] »).
Set map.[[WeakMapData]] to a new empty List.
If iterable is not present, let iterable be undefined.
If iterable is either undefined or null, return map.
Let adder be ? Get(map, "set").
If IsCallable(adder) is false, 抛出一个 TypeError 异常.
Let iteratorRecord be ? GetIterator(iterable).
Repeat,
1. Let next be ? IteratorStep(iterRecord).
2. If next is false, return map.
3. Let nextItem be ? IteratorValue(next).
4. If Type(nextItem) is not Object, then
  1. Let error be Completion{[[Type]]: throw, [[Value]]: a newly created TypeError object, [[Target]]: empty}.
  2. Return ? IteratorClose(iteratorRecord, error).
5. Let k be Get(nextItem, "0").
6. If k is an abrupt completion, return ? IteratorClose(iteratorRecord, k).
7. Let v be Get(nextItem, "1").
8. If v is an abrupt completion, return ? IteratorClose(iteratorRecord, v).
9. Let status be Call(adder, map, « k.[[Value]], v.[[Value]] »).
10. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).

Note

If the parameter iterable is present, it is expected to be an object that implements an @@迭代器 method that returns an 迭代器 object that produces a two element array-like object whose first element is a value that will be used as a WeakMap key and whose second element is the value to associate with that key.

23.3.2Properties of the WeakMap 构造器

[[Prototype]] 内部属性的值 of the WeakMap 构造器 is the 内部对象 %FunctionPrototype%.

The WeakMap 构造器有以下属性:

23.3.2.1WeakMap.prototype

The 初始值 of WeakMap.prototype is the 内部对象 %WeakMapPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

23.3.3Properties of the WeakMap 原型对象

The WeakMap 原型对象 is the 内部对象 %WeakMapPrototype%. [[Prototype]] 内部属性的值 of the WeakMap 原型对象 is the 内部对象 %ObjectPrototype%. The WeakMap 原型对象 is an 普通对象. It does not have a [[WeakMapData]] 内部属性.

23.3.3.1WeakMap.prototype.constructor

The 初始值 of WeakMap.prototype.constructor is the 内部对象 %WeakMap%.

23.3.3.2WeakMap.prototype.delete ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[WeakMapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[WeakMapData]].
If Type(key) is not Object, return false.
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
  1. Set p.[[Key]] to empty.
  2. Set p.[[Value]] to empty.
  3. Return true.
Return false.

Note

23.3.3.3WeakMap.prototype.get ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[WeakMapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[WeakMapData]].
If Type(key) is not Object, return undefined.
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return p.[[Value]].
Return undefined.

23.3.3.4WeakMap.prototype.has ( `key` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[WeakMapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[WeakMapData]].
If Type(key) is not Object, return false.
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, return true.
Return false.

23.3.3.5WeakMap.prototype.set ( `key`, `value` )

执行如下:

Let M be the this value.
If Type(M) is not Object, 抛出一个 TypeError 异常.
If M does not have a [[WeakMapData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is M.[[WeakMapData]].
If Type(key) is not Object, 抛出一个 TypeError 异常.
For each Record {[[Key]], [[Value]]} p that is an element of entries, do
1. If p.[[Key]] is not empty and SameValue(p.[[Key]], key) is true, then
  1. Set p.[[Value]] to value.
  2. Return M.
Let p be the Record {[[Key]]: key, [[Value]]: value}.
Append p as the last element of entries.
Return M.

23.3.3.6WeakMap.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "WeakMap".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.3.4Properties of WeakMap 实例

WeakMap 实例 are 普通对象 that 继承属性 from the WeakMap prototype. WeakMap 实例 also have a [[WeakMapData]] 内部属性.

23.4WeakSet 对象

WeakSet 对象 are collections of objects. A distinct object may only occur once as an element of a WeakSet's collection. A WeakSet may be queried to see if it contains a specific object, but no mechanism is provided for enumerating the objects it holds. If an object that is contained by a WeakSet is only reachable by following a chain of references that start within that WeakSet, then that object is inaccessible and is automatically removed from the WeakSet. WeakSet implementations must detect and remove such objects and any associated resources.

An 实现 may impose an arbitrarily determined latency between the time an object contained in a WeakSet becomes inaccessible and the time when the object is removed from the WeakSet. If this latency was observable to ES 程序, it would be a source of indeterminacy that could impact program execution. For that reason, an ES 实现 must not provide any means to determine if a WeakSet contains a particular object that does not require the observer to present the observed object.

WeakSet 对象 must be implemented using either hash tables or other mechanisms that, on average, provide access times that are sublinear on the number of elements in the collection. The data structure used in this WeakSet 对象 specification is only intended to describe the required observable 语义 of WeakSet 对象. It is not intended to be a viable 实现 model.

Note

See the NOTE in 23.3.

23.4.1The WeakSet 构造器

The WeakSet 构造器 is the %WeakSet% 内部对象 and the 初始值 of the WeakSet property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 WeakSet object. WeakSet is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The WeakSet 构造器被设计成可被子类化的. 它可以用作 the value in an extends clause of a class definition. 子类构造器 that 旨在继承特定的 WeakSet behaviour must include a super call to the WeakSet 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the WeakSet.prototype 内置方法.

23.4.1.1WeakSet ( [ `iterable` ] )

When the WeakSet function is called with 可选参数 iterable, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let set be ? OrdinaryCreateFromConstructor(NewTarget, "%WeakSetPrototype%", « [[WeakSetData]] »).
Set set.[[WeakSetData]] to a new empty List.
If iterable is not present, let iterable be undefined.
If iterable is either undefined or null, return set.
Let adder be ? Get(set, "add").
If IsCallable(adder) is false, 抛出一个 TypeError 异常.
Let iteratorRecord be ? GetIterator(iterable).
Repeat,
1. Let next be ? IteratorStep(iteratorRecord).
2. If next is false, return set.
3. Let nextValue be ? IteratorValue(next).
4. Let status be Call(adder, set, « nextValue »).
5. If status is an abrupt completion, return ? IteratorClose(iteratorRecord, status).

23.4.2Properties of the WeakSet 构造器

[[Prototype]] 内部属性的值 of the WeakSet 构造器 is the 内部对象 %FunctionPrototype%.

The WeakSet 构造器有以下属性:

23.4.2.1WeakSet.prototype

The 初始值 of WeakSet.prototype is the intrinsic %WeakSetPrototype% object.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

23.4.3Properties of the WeakSet 原型对象

The WeakSet 原型对象 is the 内部对象 %WeakSetPrototype%. [[Prototype]] 内部属性的值 of the WeakSet 原型对象 is the 内部对象 %ObjectPrototype%. The WeakSet 原型对象 is an 普通对象. It does not have a [[WeakSetData]] 内部属性.

23.4.3.1WeakSet.prototype.add ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[WeakSetData]] 内部属性, 抛出一个 TypeError 异常.
If Type(value) is not Object, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[WeakSetData]].
For each e that is an element of entries, do
1. If e is not empty and SameValue(e, value) is true, then
  1. Return S.
Append value as the last element of entries.
Return S.

23.4.3.2WeakSet.prototype.constructor

The 初始值 of WeakSet.prototype.constructor is the %WeakSet% 内部对象.

23.4.3.3WeakSet.prototype.delete ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[WeakSetData]] 内部属性, 抛出一个 TypeError 异常.
If Type(value) is not Object, return false.
Let entries be the List that is S.[[WeakSetData]].
For each e that is an element of entries, do
1. If e is not empty and SameValue(e, value) is true, then
  1. Replace the element of entries whose value is e with an element whose value is empty.
  2. Return true.
Return false.

Note

23.4.3.4WeakSet.prototype.has ( `value` )

执行如下:

Let S be the this value.
If Type(S) is not Object, 抛出一个 TypeError 异常.
If S does not have a [[WeakSetData]] 内部属性, 抛出一个 TypeError 异常.
Let entries be the List that is S.[[WeakSetData]].
If Type(value) is not Object, return false.
For each e that is an element of entries, do
1. If e is not empty and SameValue(e, value) is true, return true.
Return false.

23.4.3.5WeakSet.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "WeakSet".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

23.4.4Properties of WeakSet Instances

WeakSet instances are 普通对象 that 继承属性 from the WeakSet prototype. WeakSet instances also have a [[WeakSetData]] 内部属性.

24结构化数据

24.1ArrayBuffer 对象

24.1.1ArrayBuffer 对象的抽象操作

24.1.1.1AllocateArrayBuffer ( `构造器`, `byteLength` )

The 抽象操作 AllocateArrayBuffer with arguments 构造器 and byteLength is used to create an ArrayBuffer object. It 执行如下:

Let obj be ? OrdinaryCreateFromConstructor(构造器, "%ArrayBufferPrototype%", « [[ArrayBufferData]], [[ArrayBufferByteLength]] »).
Assert: byteLength is an integer value ≥ 0.
Let block be ? CreateByteDataBlock(byteLength).
Set obj.[[ArrayBufferData]] to block.
Set obj.[[ArrayBufferByteLength]] to byteLength.
Return obj.

24.1.1.2IsDetachedBuffer ( `arrayBuffer` )

The 抽象操作 IsDetachedBuffer with argument arrayBuffer 执行如下:

Assert: Type(arrayBuffer) is Object and it has an [[ArrayBufferData]] 内部属性.
If arrayBuffer.[[ArrayBufferData]] is null, return true.
Return false.

24.1.1.3DetachArrayBuffer ( `arrayBuffer` )

The 抽象操作 DetachArrayBuffer with argument arrayBuffer 执行如下:

Assert: Type(arrayBuffer) is Object and it has [[ArrayBufferData]] and [[ArrayBufferByteLength]] 内部属性.
Assert: IsSharedArrayBuffer(arrayBuffer) is false.
Set arrayBuffer.[[ArrayBufferData]] to null.
Set arrayBuffer.[[ArrayBufferByteLength]] to 0.
Return NormalCompletion(null).

Note

Detaching an ArrayBuffer instance disassociates the 数据块 used as its backing store from the instance and sets the byte length of the buffer to 0. No operations defined by this specification use the DetachArrayBuffer 抽象操作. However, an ES 实现 or host environment may define such operations.

24.1.1.4CloneArrayBuffer ( `srcBuffer`, `srcByteOffset`, `srcLength`, `cloneConstructor` )

The 抽象操作 CloneArrayBuffer takes four parameters, an ArrayBuffer srcBuffer, an integer offset srcByteOffset, an integer length srcLength, and a 构造器 function cloneConstructor. It creates a new ArrayBuffer whose data is a copy of srcBuffer's data over the range starting at srcByteOffset and continuing for srcLength bytes. This operation 执行如下:

Assert: Type(srcBuffer) is Object and it has an [[ArrayBufferData]] 内部属性.
Assert: IsConstructor(cloneConstructor) is true.
Let targetBuffer be ? AllocateArrayBuffer(cloneConstructor, srcLength).
If IsDetachedBuffer(srcBuffer) is true, 抛出一个 TypeError 异常.
Let srcBlock be srcBuffer.[[ArrayBufferData]].
Let targetBlock be targetBuffer.[[ArrayBufferData]].
Perform CopyDataBlockBytes(targetBlock, 0, srcBlock, srcByteOffset, srcLength).
Return targetBuffer.

24.1.1.5RawBytesToNumber( `type`, `rawBytes`, `isLittleEndian` )

The 抽象操作 RawBytesToNumber takes three parameters, a String type, a List rawBytes, and a Boolean isLittleEndian. This operation 执行如下:

Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If isLittleEndian is false, reverse the order of the elements of rawBytes.
If type is "Float32", then
1. Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary32 value.
2. If value is an IEEE 754-2008 binary32 NaN value, return the NaN Number 值.
3. Return the Number 值 that corresponds to value.
If type is "Float64", then
1. Let value be the byte elements of rawBytes concatenated and interpreted as a little-endian bit string encoding of an IEEE 754-2008 binary64 value.
2. If value is an IEEE 754-2008 binary64 NaN value, return the NaN Number 值.
3. Return the Number 值 that corresponds to value.
If the first 代码单元 of type is the 代码单元 0x0055 (LATIN CAPITAL LETTER U), then
1. Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of an unsigned little-endian binary number.
Else,
1. Let intValue be the byte elements of rawBytes concatenated and interpreted as a bit string encoding of a binary little-endian 2's complement number of bit length elementSize × 8.
Return the Number 值 that corresponds to intValue.

24.1.1.6GetValueFromBuffer ( `arrayBuffer`, `byteIndex`, `type`, `isTypedArray`, `order` [ , `isLittleEndian` ] )

The 抽象操作 GetValueFromBuffer takes six parameters, an ArrayBuffer or SharedArrayBuffer arrayBuffer, an integer byteIndex, a String type, a Boolean isTypedArray, a String order, and optionally a Boolean isLittleEndian. This operation 执行如下:

Assert: IsDetachedBuffer(arrayBuffer) is false.
Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
Assert: byteIndex is an integer value ≥ 0.
Let block be arrayBuffer.[[ArrayBufferData]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If IsSharedArrayBuffer(arrayBuffer) is true, then
1. Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
2. Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
3. If isTypedArray is true and type is "Int8", "Uint8", "Int16", "Uint16", "Int32", or "Uint32", let noTear be true; otherwise let noTear be false.
4. Let rawValue be a List of length elementSize of nondeterministically chosen byte values.
5. NOTE: In implementations, rawValue is the result of a non-atomic or atomic read instruction on the underlying hardware. The nondeterminism is a semantic prescription of the 内存模型 to describe observable behaviour of hardware with weak consistency.
6. Let readEvent be ReadSharedMemory{ [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize }.
7. Append readEvent to eventList.
8. Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: rawValue } to execution.[[ChosenValues]].
Else, let rawValue be a List of elementSize containing, in order, the elementSize sequence of bytes starting with block[byteIndex].
If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
Return RawBytesToNumber(type, rawValue, isLittleEndian).

24.1.1.7NumberToRawBytes( `type`, `value`, `isLittleEndian` )

The 抽象操作 NumberToRawBytes takes three parameters, a String type, a Number value, and a Boolean isLittleEndian. This operation 执行如下:

If type is "Float32", then
1. Let rawBytes be a List containing the 4 bytes that are the result of converting value to IEEE 754-2008 binary32 format using “Round to nearest, ties to even” rounding mode. If isLittleEndian is false, the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. If value is NaN, rawBytes may be set to any 实现 chosen IEEE 754-2008 binary32 format Not-a-Number encoding. An 实现 must always choose the same encoding for each 实现 distinguishable NaN value.
Else if type is "Float64", then
1. Let rawBytes be a List containing the 8 bytes that are the IEEE 754-2008 binary64 format encoding of value. If isLittleEndian is false, the bytes are arranged in big endian order. Otherwise, the bytes are arranged in little endian order. If value is NaN, rawBytes may be set to any 实现 chosen IEEE 754-2008 binary64 format Not-a-Number encoding. An 实现 must always choose the same encoding for each 实现 distinguishable NaN value.
Else,
1. Let n be the Number 值 of the Element Size specified in Table 56 for Element Type type.
2. Let convOp be the 抽象操作 named in the Conversion Operation column in Table 56 for Element Type type.
3. Let intValue be convOp(value).
4. If intValue ≥ 0, then
  1. Let rawBytes be a List containing the n-byte binary encoding of intValue. If isLittleEndian is false, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
5. Else,
  1. Let rawBytes be a List containing the n-byte binary 2's complement encoding of intValue. If isLittleEndian is false, the bytes are ordered in big endian order. Otherwise, the bytes are ordered in little endian order.
Return rawBytes.

24.1.1.8SetValueInBuffer ( `arrayBuffer`, `byteIndex`, `type`, `value`, `isTypedArray`, `order` [ , `isLittleEndian` ] )

The 抽象操作 SetValueInBuffer takes seven parameters, an ArrayBuffer or SharedArrayBuffer arrayBuffer, an integer byteIndex, a String type, a Number value, a Boolean isTypedArray, a String order, and optionally a Boolean isLittleEndian. This operation 执行如下:

Assert: IsDetachedBuffer(arrayBuffer) is false.
Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
Assert: byteIndex is an integer value ≥ 0.
Assert: Type(value) is Number.
Let block be arrayBuffer.[[ArrayBufferData]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
Let rawBytes be NumberToRawBytes(type, value, isLittleEndian).
If IsSharedArrayBuffer(arrayBuffer) is true, then
1. Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
2. Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
3. If isTypedArray is true and type is "Int8", "Uint8", "Int16", "Uint16", "Int32", or "Uint32", let noTear be true; otherwise let noTear be false.
4. Append WriteSharedMemory{ [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize, [[Payload]]: rawBytes } to eventList.
Else, store the individual bytes of rawBytes into block, in order, starting at block[byteIndex].
Return NormalCompletion(undefined).

24.1.1.9GetModifySetValueInBuffer( `arrayBuffer`, `byteIndex`, `type`, `value`, `op` [ , `isLittleEndian` ] )

The 抽象操作 GetModifySetValueInBuffer takes six parameters, a SharedArrayBuffer arrayBuffer, 一个非负整数 byteIndex, a String type, a Number value, a semantic function op, and optionally a Boolean isLittleEndian. This operation 执行如下:

Assert: IsSharedArrayBuffer(arrayBuffer) is true.
Assert: There are sufficient bytes in arrayBuffer starting at byteIndex to represent a value of type.
Assert: byteIndex is an integer value ≥ 0.
Assert: Type(value) is Number.
Let block be arrayBuffer.[[ArrayBufferData]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If isLittleEndian is not present, set isLittleEndian to the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
Let rawBytes be NumberToRawBytes(type, value, isLittleEndian).
Let execution be the [[CandidateExecution]] field of the surrounding agent's Agent Record.
Let eventList be the [[EventList]] field of the element in execution.[[EventLists]] whose [[AgentSignifier]] is AgentSignifier().
Let rawBytesRead be a List of length elementSize of nondeterministically chosen byte values.
NOTE: In implementations, rawBytesRead is the result of a load-link, of a load-exclusive, or of an operand of a read-modify-write instruction on the underlying hardware. The nondeterminism is a semantic prescription of the 内存模型 to describe observable behaviour of hardware with weak consistency.
Let rmwEvent be ReadModifyWriteSharedMemory{ [[Order]]: "SeqCst", [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize, [[Payload]]: rawBytes, [[ModifyOp]]: op }.
Append rmwEvent to eventList.
Append Chosen Value Record { [[Event]]: rmwEvent, [[ChosenValue]]: rawBytesRead } to execution.[[ChosenValues]].
Return RawBytesToNumber(type, rawBytesRead, isLittleEndian).

24.1.2The ArrayBuffer 构造器

The ArrayBuffer 构造器 is the %ArrayBuffer% 内部对象 and the 初始值 of the ArrayBuffer property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 ArrayBuffer object. ArrayBuffer is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The ArrayBuffer 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 ArrayBuffer behaviour must include a super call to the ArrayBuffer 构造器 to create and initialize subclass instances with the 内部状态 necessary to support the ArrayBuffer.prototype 内置方法.

24.1.2.1ArrayBuffer ( `length` )

When the ArrayBuffer function is called with argument length, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let byteLength be ? ToIndex(length).
Return ? AllocateArrayBuffer(NewTarget, byteLength).

24.1.3Properties of the ArrayBuffer 构造器

[[Prototype]] 内部属性的值 of the ArrayBuffer 构造器 is the 内部对象 %FunctionPrototype%.

The ArrayBuffer 构造器有以下属性:

24.1.3.1ArrayBuffer.isView ( `arg` )

The isView function takes one argument arg, and performs, 执行如下:

If Type(arg) is not Object, return false.
If arg has a [[ViewedArrayBuffer]] 内部属性, return true.
Return false.

24.1.3.2ArrayBuffer.prototype

The 初始值 of ArrayBuffer.prototype is the 内部对象 %ArrayBufferPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

24.1.3.3get ArrayBuffer [ @@species ]

ArrayBuffer[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

ArrayBuffer prototype methods normally use their this object's 构造器 to create a derived object. However, a subclass 构造器 may over-ride that default behaviour by redefining its @@species property.

24.1.4Properties of the ArrayBuffer 原型对象

The ArrayBuffer 原型对象 is the 内部对象 %ArrayBufferPrototype%. [[Prototype]] 内部属性的值 of the ArrayBuffer 原型对象 is the 内部对象 %ObjectPrototype%. The ArrayBuffer 原型对象 is an 普通对象. It does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] 内部属性.

24.1.4.1get ArrayBuffer.prototype.byteLength

ArrayBuffer.prototype.byteLength is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(O) is true, 抛出一个 TypeError 异常.
If IsDetachedBuffer(O) is true, 抛出一个 TypeError 异常.
Let length be O.[[ArrayBufferByteLength]].
Return length.

24.1.4.2ArrayBuffer.prototype.constructor

The 初始值 of ArrayBuffer.prototype.constructor is the 内部对象 %ArrayBuffer%.

24.1.4.3ArrayBuffer.prototype.slice ( `start`, `end` )

执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(O) is true, 抛出一个 TypeError 异常.
If IsDetachedBuffer(O) is true, 抛出一个 TypeError 异常.
Let len be O.[[ArrayBufferByteLength]].
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let first be max((len + relativeStart), 0); else let first be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let newLen be max(final-first, 0).
Let ctor be ? SpeciesConstructor(O, %ArrayBuffer%).
Let new be ? Construct(ctor, « newLen »).
If new does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(new) is true, 抛出一个 TypeError 异常.
If IsDetachedBuffer(new) is true, 抛出一个 TypeError 异常.
If SameValue(new, O) is true, 抛出一个 TypeError 异常.
If new.[[ArrayBufferByteLength]] < newLen, 抛出一个 TypeError 异常.
NOTE: Side-effects of the above steps may have detached O.
If IsDetachedBuffer(O) is true, 抛出一个 TypeError 异常.
Let fromBuf be O.[[ArrayBufferData]].
Let toBuf be new.[[ArrayBufferData]].
Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
Return new.

24.1.4.4ArrayBuffer.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "ArrayBuffer".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

24.1.5Properties of the ArrayBuffer Instances

ArrayBuffer instances 继承属性 from the ArrayBuffer 原型对象. ArrayBuffer instances each have an [[ArrayBufferData]] 内部属性 and an [[ArrayBufferByteLength]] 内部属性.

ArrayBuffer instances whose [[ArrayBufferData]] is null are considered to be detached and all operators to access or modify data contained in the ArrayBuffer instance will fail.

24.2SharedArrayBuffer 对象

24.2.1抽象操作 for SharedArrayBuffer 对象

24.2.1.1AllocateSharedArrayBuffer( `构造器`, `byteLength` )

The 抽象操作 AllocateSharedArrayBuffer with arguments 构造器 and byteLength is used to create a SharedArrayBuffer object. It 执行如下:

Let obj be ? OrdinaryCreateFromConstructor(构造器, "%SharedArrayBufferPrototype%", « [[ArrayBufferData]], [[ArrayBufferByteLength]] »).
Assert: byteLength is 一个非负整数.
Let block be ? CreateSharedByteDataBlock(byteLength).
Set obj.[[ArrayBufferData]] to block.
Set obj.[[ArrayBufferByteLength]] to byteLength.
Return obj.

24.2.1.2IsSharedArrayBuffer( `obj` )

IsSharedArrayBuffer tests whether an object is an ArrayBuffer, a SharedArrayBuffer, or a subtype of either. It 执行如下:

Assert: Type(obj) is Object and it has an [[ArrayBufferData]] 内部属性.
Let bufferData be obj.[[ArrayBufferData]].
If bufferData is null, return false.
If bufferData is a 数据块, return false.
Assert: bufferData is a 共享数据块.
Return true.

24.2.2The SharedArrayBuffer 构造器

The SharedArrayBuffer 构造器 is the %SharedArrayBuffer% 内部对象 and the 初始值 of the SharedArrayBuffer property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 SharedArrayBuffer object. SharedArrayBuffer is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The SharedArrayBuffer 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 SharedArrayBuffer behaviour must include a super call to the SharedArrayBuffer 构造器 to create and initialize subclass instances with the 内部状态 necessary to support the SharedArrayBuffer.prototype 内置方法.

Note

Unlike an ArrayBuffer, a SharedArrayBuffer cannot become detached, and its internal [[ArrayBufferData]] slot is never null.

24.2.2.1SharedArrayBuffer( `length` )

When the SharedArrayBuffer function is called with 可选参数 length, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Let byteLength be ? ToIndex(length).
Return ? AllocateSharedArrayBuffer(NewTarget, byteLength).

24.2.3Properties of the SharedArrayBuffer 构造器

[[Prototype]] 内部属性的值 of the SharedArrayBuffer 构造器 is the 内部对象 %FunctionPrototype%.

The SharedArrayBuffer 构造器有以下属性:

24.2.3.1SharedArrayBuffer.prototype

The 初始值 of SharedArrayBuffer.prototype is the 内部对象 %SharedArrayBufferPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

24.2.3.2get SharedArrayBuffer [ @@species ]

SharedArrayBuffer[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

24.2.4Properties of the SharedArrayBuffer 原型对象

The SharedArrayBuffer 原型对象 is the 内部对象 %SharedArrayBufferPrototype%. [[Prototype]] 内部属性的值 of the SharedArrayBuffer 原型对象 is the 内部对象 %ObjectPrototype%. The SharedArrayBuffer 原型对象 is an 普通对象. It does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] 内部属性.

24.2.4.1get SharedArrayBuffer.prototype.byteLength

SharedArrayBuffer.prototype.byteLength is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(O) is false, 抛出一个 TypeError 异常.
Let length be O.[[ArrayBufferByteLength]].
Return length.

24.2.4.2SharedArrayBuffer.prototype.constructor

The 初始值 of SharedArrayBuffer.prototype.constructor is the 内部对象 %SharedArrayBuffer%.

24.2.4.3SharedArrayBuffer.prototype.slice( `start`, `end` )

执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(O) is false, 抛出一个 TypeError 异常.
Let len be O.[[ArrayBufferByteLength]].
Let relativeStart be ? ToInteger(start).
If relativeStart < 0, let first be max((len + relativeStart), 0); else let first be min(relativeStart, len).
If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToInteger(end).
If relativeEnd < 0, let final be max((len + relativeEnd), 0); else let final be min(relativeEnd, len).
Let newLen be max(final - first, 0).
Let ctor be ? SpeciesConstructor(O, %SharedArrayBuffer%).
Let new be ? Construct(ctor, « newLen »).
If new does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
If IsSharedArrayBuffer(new) is false, 抛出一个 TypeError 异常.
If new.[[ArrayBufferData]] and O.[[ArrayBufferData]] are the same 共享数据块 values, 抛出一个 TypeError 异常.
If new.[[ArrayBufferByteLength]] < newLen, 抛出一个 TypeError 异常.
Let fromBuf be O.[[ArrayBufferData]].
Let toBuf be new.[[ArrayBufferData]].
Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
Return new.

24.2.4.4SharedArrayBuffer.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "SharedArrayBuffer".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

24.2.5Properties of the SharedArrayBuffer Instances

SharedArrayBuffer instances 继承属性 from the SharedArrayBuffer 原型对象. SharedArrayBuffer instances each have an [[ArrayBufferData]] 内部属性 and an [[ArrayBufferByteLength]] 内部属性.

Note

SharedArrayBuffer instances, unlike ArrayBuffer instances, are never detached.

24.3DataView 对象

24.3.1抽象操作 For DataView 对象

24.3.1.1GetViewValue ( `view`, `requestIndex`, `isLittleEndian`, `type` )

The 抽象操作 GetViewValue with arguments view, requestIndex, isLittleEndian, and type is used by functions on DataView instances to retrieve values from the view's buffer. It 执行如下:

If Type(view) is not Object, 抛出一个 TypeError 异常.
If view does not have a [[DataView]] 内部属性, 抛出一个 TypeError 异常.
Assert: view has a [[ViewedArrayBuffer]] 内部属性.
Let getIndex be ? ToIndex(requestIndex).
Set isLittleEndian to ToBoolean(isLittleEndian).
Let buffer be view.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let viewOffset be view.[[ByteOffset]].
Let viewSize be view.[[ByteLength]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If getIndex + elementSize > viewSize, 抛出一个 RangeError 异常.
Let bufferIndex be getIndex + viewOffset.
Return GetValueFromBuffer(buffer, bufferIndex, type, false, "Unordered", isLittleEndian).

24.3.1.2SetViewValue ( `view`, `requestIndex`, `isLittleEndian`, `type`, `value` )

The 抽象操作 SetViewValue with arguments view, requestIndex, isLittleEndian, type, and value is used by functions on DataView instances to store values into the view's buffer. It 执行如下:

If Type(view) is not Object, 抛出一个 TypeError 异常.
If view does not have a [[DataView]] 内部属性, 抛出一个 TypeError 异常.
Assert: view has a [[ViewedArrayBuffer]] 内部属性.
Let getIndex be ? ToIndex(requestIndex).
Let numberValue be ? ToNumber(value).
Set isLittleEndian to ToBoolean(isLittleEndian).
Let buffer be view.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let viewOffset be view.[[ByteOffset]].
Let viewSize be view.[[ByteLength]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for Element Type type.
If getIndex + elementSize > viewSize, 抛出一个 RangeError 异常.
Let bufferIndex be getIndex + viewOffset.
Return SetValueInBuffer(buffer, bufferIndex, type, numberValue, false, "Unordered", isLittleEndian).

24.3.2The DataView 构造器

The DataView 构造器 is the %DataView% 内部对象 and the 初始值 of the DataView property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 DataView object. DataView is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The DataView 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 DataView behaviour must include a super call to the DataView 构造器 to create and initialize subclass instances with the 内部状态 necessary to support the DataView.prototype 内置方法.

24.3.2.1DataView ( `buffer` [ , `byteOffset` [ , `byteLength` ] ] )

When the DataView is called with at least one argument buffer, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
If Type(buffer) is not Object, 抛出一个 TypeError 异常.
If buffer does not have an [[ArrayBufferData]] 内部属性, 抛出一个 TypeError 异常.
Let offset be ? ToIndex(byteOffset).
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let bufferByteLength be buffer.[[ArrayBufferByteLength]].
If offset > bufferByteLength, 抛出一个 RangeError 异常.
If byteLength is either not present or undefined, then
1. Let viewByteLength be bufferByteLength - offset.
Else,
1. Let viewByteLength be ? ToIndex(byteLength).
2. If offset+viewByteLength > bufferByteLength, 抛出一个 RangeError 异常.
Let O be ? OrdinaryCreateFromConstructor(NewTarget, "%DataViewPrototype%", « [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], [[ByteOffset]] »).
Set O.[[ViewedArrayBuffer]] to buffer.
Set O.[[ByteLength]] to viewByteLength.
Set O.[[ByteOffset]] to offset.
Return O.

24.3.3Properties of the DataView 构造器

[[Prototype]] 内部属性的值 of the DataView 构造器 is the 内部对象 %FunctionPrototype%.

The DataView 构造器有以下属性:

24.3.3.1DataView.prototype

The 初始值 of DataView.prototype is the 内部对象 %DataViewPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

24.3.4Properties of the DataView 原型对象

The DataView 原型对象 is the 内部对象 %DataViewPrototype%. [[Prototype]] 内部属性的值 of the DataView 原型对象 is the 内部对象 %ObjectPrototype%. The DataView 原型对象 is an 普通对象. It does not have a [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], or [[ByteOffset]] 内部属性.

24.3.4.1get DataView.prototype.buffer

DataView.prototype.buffer is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[DataView]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
Return buffer.

24.3.4.2get DataView.prototype.byteLength

DataView.prototype.byteLength is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[DataView]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let size be O.[[ByteLength]].
Return size.

24.3.4.3get DataView.prototype.byteOffset

DataView.prototype.byteOffset is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Let O be the this value.
If Type(O) is not Object, 抛出一个 TypeError 异常.
If O does not have a [[DataView]] 内部属性, 抛出一个 TypeError 异常.
Assert: O has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be O.[[ViewedArrayBuffer]].
If IsDetachedBuffer(buffer) is true, 抛出一个 TypeError 异常.
Let offset be O.[[ByteOffset]].
Return offset.

24.3.4.4DataView.prototype.constructor

The 初始值 of DataView.prototype.constructor is the 内部对象 %DataView%.

24.3.4.5DataView.prototype.getFloat32 ( `byteOffset` [ , `littleEndian` ] )

When the getFloat32 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? GetViewValue(v, byteOffset, littleEndian, "Float32").

24.3.4.6DataView.prototype.getFloat64 ( `byteOffset` [ , `littleEndian` ] )

When the getFloat64 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? GetViewValue(v, byteOffset, littleEndian, "Float64").

24.3.4.7DataView.prototype.getInt8 ( `byteOffset` )

When the getInt8 method is called with argument byteOffset, 执行如下:

Let v be the this value.
Return ? GetViewValue(v, byteOffset, true, "Int8").

24.3.4.8DataView.prototype.getInt16 ( `byteOffset` [ , `littleEndian` ] )

When the getInt16 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? GetViewValue(v, byteOffset, littleEndian, "Int16").

24.3.4.9DataView.prototype.getInt32 ( `byteOffset` [ , `littleEndian` ] )

When the getInt32 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be undefined.
Return ? GetViewValue(v, byteOffset, littleEndian, "Int32").

24.3.4.10DataView.prototype.getUint8 ( `byteOffset` )

When the getUint8 method is called with argument byteOffset, 执行如下:

Let v be the this value.
Return ? GetViewValue(v, byteOffset, true, "Uint8").

24.3.4.11DataView.prototype.getUint16 ( `byteOffset` [ , `littleEndian` ] )

When the getUint16 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? GetViewValue(v, byteOffset, littleEndian, "Uint16").

24.3.4.12DataView.prototype.getUint32 ( `byteOffset` [ , `littleEndian` ] )

When the getUint32 method is called with argument byteOffset and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? GetViewValue(v, byteOffset, littleEndian, "Uint32").

24.3.4.13DataView.prototype.setFloat32 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setFloat32 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Float32", value).

24.3.4.14DataView.prototype.setFloat64 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setFloat64 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Float64", value).

24.3.4.15DataView.prototype.setInt8 ( `byteOffset`, `value` )

When the setInt8 method is called with arguments byteOffset and value, 执行如下:

Let v be the this value.
Return ? SetViewValue(v, byteOffset, true, "Int8", value).

24.3.4.16DataView.prototype.setInt16 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setInt16 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Int16", value).

24.3.4.17DataView.prototype.setInt32 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setInt32 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Int32", value).

24.3.4.18DataView.prototype.setUint8 ( `byteOffset`, `value` )

When the setUint8 method is called with arguments byteOffset and value, 执行如下:

Let v be the this value.
Return ? SetViewValue(v, byteOffset, true, "Uint8", value).

24.3.4.19DataView.prototype.setUint16 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setUint16 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Uint16", value).

24.3.4.20DataView.prototype.setUint32 ( `byteOffset`, `value` [ , `littleEndian` ] )

When the setUint32 method is called with arguments byteOffset and value and 可选参数 littleEndian, 执行如下:

Let v be the this value.
If littleEndian is not present, let littleEndian be false.
Return ? SetViewValue(v, byteOffset, littleEndian, "Uint32", value).

24.3.4.21DataView.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "DataView".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

24.3.5Properties of DataView Instances

DataView instances are 普通对象 that 继承属性 from the DataView 原型对象. DataView instances each have [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], and [[ByteOffset]] 内部属性.

Note

The value of the [[DataView]] 内部属性 is not used within this specification. The simple presence of that 内部属性 is used within the specification to identify objects created using the DataView 构造器.

24.4Atomics 对象

Atomics 对象 is the %Atomics% 内部对象 and the 初始值 of the Atomics property of the 全局对象. Atomics 对象 is a single 普通对象.

Atomics 对象 provides functions that operate indivisibly (atomically) on shared memory array cells as well as functions that let 代理 wait for and dispatch primitive events. When used with discipline, the Atomics functions allow multi-agent programs that communicate through shared memory to execute in a well-understood order even on parallel CPUs. The rules that govern shared-memory communication are provided by the 内存模型, defined below.

[[Prototype]] 内部属性的值 of Atomics 对象 is the 内部对象 %ObjectPrototype%.

Atomics 对象 does not have a [[Construct]] 内部方法; it is not possible to use Atomics 对象 as a 构造器 with new 运算符.

Atomics 对象 does not have a [[Call]] 内部方法; it is not possible to invoke Atomics 对象 as a function.

Note

For informative guidelines for programming and implementing shared memory in ES, please see the notes at the end of the 内存模型 section.

24.4.1抽象操作 for Atomics

24.4.1.1ValidateSharedIntegerTypedArray(`typedArray` [ , `onlyInt32` ] )

The 抽象操作 ValidateSharedIntegerTypedArray takes one argument typedArray and an optional Boolean onlyInt32. It 执行如下:

If onlyInt32 is not present, set onlyInt32 to false.
If Type(typedArray) is not Object, 抛出一个 TypeError 异常.
If typedArray does not have a [[TypedArrayName]] 内部属性, 抛出一个 TypeError 异常.
Let typeName be typedArray.[[TypedArrayName]].
If onlyInt32 is true, then
1. If typeName is not "Int32Array", 抛出一个 TypeError 异常.
Else,
1. If typeName is not "Int8Array", "Uint8Array", "Int16Array", "Uint16Array", "Int32Array", or "Uint32Array", 抛出一个 TypeError 异常.
Assert: typedArray has a [[ViewedArrayBuffer]] 内部属性.
Let buffer be typedArray.[[ViewedArrayBuffer]].
If IsSharedArrayBuffer(buffer) is false, 抛出一个 TypeError 异常.
Return buffer.

24.4.1.2ValidateAtomicAccess( `typedArray`, `requestIndex` )

The 抽象操作 ValidateAtomicAccess takes two arguments, typedArray and requestIndex. It 执行如下:

Assert: typedArray is an Object that has a [[ViewedArrayBuffer]] 内部属性.
Let accessIndex be ? ToIndex(requestIndex).
Let length be typedArray.[[ArrayLength]].
Assert: accessIndex ≥ 0.
If accessIndex ≥ length, 抛出一个 RangeError 异常.
Return accessIndex.

24.4.1.3GetWaiterList( `block`, `i` )

A WaiterList is a semantic object that contains an ordered list of those 代理 that are waiting on a location (block, i) in shared memory; block is a 共享数据块 and i a byte offset into the memory of block.

The agent cluster has a store of WaiterList objects; the store is indexed by (block, i). WaiterLists are agent-independent: a lookup in the store of WaiterLists by (block, i) will result in the same WaiterList object in any agent in the agent cluster.

Operations on a WaiterList -- adding and removing waiting 代理, traversing the list of 代理, suspending and waking 代理 on the list -- may only be performed by 代理 that have entered the WaiterList's critical section.

The 抽象操作 GetWaiterList takes two arguments, a 共享数据块 block and 一个非负整数 i. It 执行如下:

Assert: block is a 共享数据块.
Assert: i and i+3 are valid byte offsets within the memory of block.
Assert: i is divisible by 4.
Return the WaiterList that is referenced by the pair (block, i).

24.4.1.4EnterCriticalSection( `WL` )

The 抽象操作 EnterCriticalSection takes one argument, a WaiterList WL. It 执行如下:

Assert: The calling agent is not in the critical section for any WaiterList.
Wait until no agent is in the critical section for WL, then enter the critical section for WL (without allowing any other agent to enter).

24.4.1.5LeaveCriticalSection( `WL` )

The 抽象操作 LeaveCriticalSection takes one argument, a WaiterList WL. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Leave the critical section for WL.

24.4.1.6AddWaiter( `WL`, `W` )

The 抽象操作 AddWaiter takes two arguments, a WaiterList WL and an agent signifier W. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Assert: W is not on the list of waiters in any WaiterList.
Add W to the end of the list of waiters in WL.

24.4.1.7RemoveWaiter( `WL`, `W` )

The 抽象操作 RemoveWaiter takes two arguments, a WaiterList WL and an agent signifier W. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Assert: W is on the list of waiters in WL.
Remove W from the list of waiters in WL.

24.4.1.8RemoveWaiters( `WL`, `c` )

The 抽象操作 RemoveWaiters takes two arguments, a WaiterList WL and nonnegative integer c. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Let L be a new empty List.
Let S be a reference to the list of waiters in WL.
Repeat, while c > 0 and S is not an empty List,
1. Let W be the first waiter in S.
2. Add W to the end of L.
3. Remove W from S.
4. Subtract 1 from c.
Return L.

24.4.1.9Suspend( `WL`, `W`, `timeout` )

The 抽象操作 Suspend takes three arguments, a WaiterList WL, an agent signifier W, and a nonnegative, non-NaN Number timeout. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Assert: W is equal to AgentSignifier().
Assert: W is on the list of waiters in WL.
Assert: AgentCanSuspend() is true.
Perform LeaveCriticalSection(WL) and suspend W for up to timeout milliseconds, performing the combined operation in such a way that a wakeup that arrives after the critical section is exited but before the suspension takes effect is not lost. W can wake up either because the timeout expired or because it was woken explicitly by another agent calling WakeWaiter(WL, W), and not for any other reasons at all.
Perform EnterCriticalSection(WL).
If W was woken explicitly by another agent calling WakeWaiter(WL, W), return true.
Return false.

24.4.1.10WakeWaiter( `WL`, `W` )

The 抽象操作 WakeWaiter takes two arguments, a WaiterList WL and an agent signifier W. It 执行如下:

Assert: The calling agent is in the critical section for WL.
Assert: W is on the list of waiters in WL.
Wake the agent W.

Note

The embedding may delay waking W, e.g. for resource management reasons, but W must eventually be woken in order to guarantee forward progress.

24.4.1.11AtomicReadModifyWrite( `typedArray`, `index`, `value`, `op` )

The 抽象操作 AtomicReadModifyWrite takes four arguments, typedArray, index, value, and a pure combining operation op. The pure combining operation op takes two List of byte values arguments and returns a List of byte values. The operation atomically loads a value, combines it with another value, and stores the result of the combination. It returns the loaded value. It 执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray).
Let i be ? ValidateAtomicAccess(typedArray, index).
Let v be ? ToInteger(value).
Let arrayTypeName be typedArray.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × elementSize) + offset.
Return GetModifySetValueInBuffer(buffer, indexedPosition, elementType, v, op).

24.4.1.12AtomicLoad( `typedArray`, `index` )

The 抽象操作 AtomicLoad takes two arguments, typedArray, index. The operation atomically loads a value and returns the loaded value. It 执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray).
Let i be ? ValidateAtomicAccess(typedArray, index).
Let arrayTypeName be typedArray.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × elementSize) + offset.
Return GetValueFromBuffer(buffer, indexedPosition, elementType, true, "SeqCst").

24.4.2Atomics.add( `typedArray`, `index`, `value` )

Let add denote a semantic function of two List of byte values arguments that applies the addition operation to the Number values corresponding to the List of byte values arguments and returns a List of byte values corresponding to the result of that operation.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, add).

24.4.3Atomics.and( `typedArray`, `index`, `value` )

Let and denote a semantic function of two List of byte values arguments that applies the bitwise-and operation element-wise to the two arguments and returns a List of byte values corresponding to the result of that operation.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, and).

24.4.4Atomics.compareExchange( `typedArray`, `index`, `expectedValue`, `replacementValue` )

执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray).
Let i be ? ValidateAtomicAccess(typedArray, index).
Let expected be ? ToInteger(expectedValue).
Let replacement be ? ToInteger(replacementValue).
Let arrayTypeName be typedArray.[[TypedArrayName]].
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Let isLittleEndian be the value of the [[LittleEndian]] field of the surrounding agent's Agent Record.
Let expectedBytes be NumberToRawBytes(elementType, expected, isLittleEndian).
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × elementSize) + offset.
Let compareExchange denote a semantic function of two List of byte values arguments that returns the second argument if the first argument is element-wise equal to expectedBytes.
Return GetModifySetValueInBuffer(buffer, indexedPosition, elementType, replacement, compareExchange).

24.4.5Atomics.exchange( `typedArray`, `index`, `value` )

Let second denote a semantic function of two List of byte values arguments that returns its second argument.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, second).

24.4.6Atomics.isLockFree( `size` )

执行如下:

Let n be ? ToInteger(size).
Let AR be the Agent Record of the surrounding agent.
If n equals 1, return AR.[[IsLockFree1]].
If n equals 2, return AR.[[IsLockFree2]].
If n equals 4, return true.
Return false.

Note

Atomics.isLockFree() is an optimization primitive. The intuition is that if the atomic step of an atomic primitive (compareExchange, load, store, add, sub, and, or, xor, or exchange) on a datum of size n bytes will be performed without the calling agent acquiring a lock outside the n bytes comprising the datum, then Atomics.isLockFree(n) will return true. High-performance 算法 will use Atomics.isLockFree to determine whether to use locks or atomic operations in critical sections. If an atomic primitive is not lock-free then it is often more efficient for an 算法 to provide its own locking.

Atomics.isLockFree(4) always returns true as that can be supported on all known relevant hardware. Being able to assume this will generally simplify programs.

24.4.7Atomics.load( `typedArray`, `index` )

执行如下:

Return ? AtomicLoad(typedArray, index).

24.4.8Atomics.or( `typedArray`, `index`, `value` )

Let or denote a semantic function of two List of byte values arguments that applies the bitwise-or operation element-wise to the two arguments and returns a List of byte values corresponding to the result of that operation.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, or).

24.4.9Atomics.store( `typedArray`, `index`, `value` )

执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray).
Let i be ? ValidateAtomicAccess(typedArray, index).
Let v be ? ToInteger(value).
Let arrayTypeName be typedArray.[[TypedArrayName]].
Let elementSize be the Number 值 of the Element Size value specified in Table 56 for arrayTypeName.
Let elementType be the String 值 of the Element Type value in Table 56 for arrayTypeName.
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × elementSize) + offset.
Perform SetValueInBuffer(buffer, indexedPosition, elementType, v, true, "SeqCst").
Return v.

24.4.10Atomics.sub( `typedArray`, `index`, `value` )

Let subtract denote a semantic function of two List of byte values arguments that applies the subtraction operation to the Number values corresponding to the List of byte values arguments and returns a List of byte values corresponding to the result of that operation.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, subtract).

24.4.11Atomics.wait( `typedArray`, `index`, `value`, `timeout` )

Atomics.wait puts the calling agent in a wait queue and puts it to sleep until it is awoken or the sleep times out. 执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray, true).
Let i be ? ValidateAtomicAccess(typedArray, index).
Let v be ? ToInt32(value).
Let q be ? ToNumber(timeout).
If q is NaN, let t be +∞, else let t be max(q, 0).
Let B be AgentCanSuspend().
If B is false, 抛出一个 TypeError 异常.
Let block be buffer.[[ArrayBufferData]].
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × 4) + offset.
Let WL be GetWaiterList(block, indexedPosition).
Perform EnterCriticalSection(WL).
Let w be ! AtomicLoad(typedArray, i).
If v is not equal to w, then
1. Perform LeaveCriticalSection(WL).
2. Return the String "not-equal".
Let W be AgentSignifier().
Perform AddWaiter(WL, W).
Let awoken be Suspend(WL, W, t).
If awoken is true, then
1. Assert: W is not on the list of waiters in WL.
Else,
1. Perform RemoveWaiter(WL, W).
Perform LeaveCriticalSection(WL).
If awoken is true, return the String "ok".
Return the String "timed-out".

24.4.12Atomics.wake( `typedArray`, `index`, `count` )

Atomics.wake wakes up some 代理 that are sleeping in the wait queue. 执行如下:

Let buffer be ? ValidateSharedIntegerTypedArray(typedArray, true).
Let i be ? ValidateAtomicAccess(typedArray, index).
If count is undefined, let c be +∞.
Else,
1. Let intCount be ? ToInteger(count).
2. Let c be max(intCount, 0).
Let block be buffer.[[ArrayBufferData]].
Let offset be typedArray.[[ByteOffset]].
Let indexedPosition be (i × 4) + offset.
Let WL be GetWaiterList(block, indexedPosition).
Let n be 0.
Perform EnterCriticalSection(WL).
Let S be RemoveWaiters(WL, c).
Repeat, while S is not an empty List,
1. Let W be the first agent in S.
2. Remove W from the front of S.
3. Perform WakeWaiter(WL, W).
4. Add 1 to n.
Perform LeaveCriticalSection(WL).
Return n.

24.4.13Atomics.xor( `typedArray`, `index`, `value` )

Let xor denote a semantic function of two List of byte values arguments that applies the bitwise-xor operation element-wise to the two arguments and returns a List of byte values corresponding to the result of that operation.

执行如下:

Return ? AtomicReadModifyWrite(typedArray, index, value, xor).

24.4.14Atomics [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Atomics".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

24.5JSON 对象

JSON 对象 is the %JSON% 内部对象 and the 初始值 of the JSON property of the 全局对象. JSON 对象 is a single 普通对象 that contains two functions, parse and stringify, that are used to parse and construct JSON texts. The JSON Data Interchange Format is defined in ECMA-404. The JSON interchange format used 在本规范中 is exactly that described by ECMA-404.

Conforming implementations of JSON.parse and JSON.stringify must support the exact interchange format described in the ECMA-404 规范 without any deletions or extensions to the format.

[[Prototype]] 内部属性的值 of JSON 对象 is the 内部对象 %ObjectPrototype%. The value of the [[Extensible]] 内部属性 of JSON 对象 is set to true.

JSON 对象 does not have a [[Construct]] 内部方法; it is not possible to use JSON 对象 as a 构造器 with new 运算符.

JSON 对象 does not have a [[Call]] 内部方法; it is not possible to invoke JSON 对象 as a function.

24.5.1JSON.parse ( `text` [ , `reviver` ] )

The parse function parses a JSON text (a JSON-formatted String) and produces an ES 值. The JSON format represents 字面量, arrays, and objects with a syntax similar to the syntax for ES 字面量, Array 初始化器, and Object 初始化器. After parsing, JSON 对象 are realized as ES 对象. JSON 数组 are realized as ES Array 实例. JSON strings, numbers, booleans, and null are realized as ES Strings, Numbers, Booleans, and null.

The optional reviver parameter is a function that takes two parameters, key and value. It can filter and transform the results. It is called with each of the key/value pairs produced by the parse, and its 返回值 is used instead of the original value. If it returns what it received, the structure is not modified. If it returns undefined then the property is deleted from the result.

Let JText be ? ToString(text).
Parse JText interpreted as UTF-16 encoded Unicode points (6.1.4) as a JSON text as specified in ECMA-404. 抛出一个 SyntaxError 异常 if JText is not a valid JSON text as defined in that specification.
Let scriptText be the string-concatenation of "(", JText, and ");".
Let completion be the result of parsing and evaluating scriptText as if it was the 源文本 of an ES Script, but using the alternative definition of DoubleStringCharacter provided below. The extended 属性定义估值语义 defined in B.3.1 must not be used during the 估值.
Let unfiltered be completion.[[Value]].
Assert: unfiltered is either a String, Number, Boolean, Null, or an Object that is defined by either an ArrayLiteral or an ObjectLiteral.
If IsCallable(reviver) is true, then
1. Let root be ObjectCreate(%ObjectPrototype%).
2. Let rootName be the empty String.
3. Let status be CreateDataProperty(root, rootName, unfiltered).
4. Assert: status is true.
5. Return ? InternalizeJSONProperty(root, rootName).
Else,
1. Return unfiltered.

This function is the %JSONParse% 内部对象.

The length property of the parse function is 2.

JSON allows Unicode 代码单元 0x2028 (LINE SEPARATOR) and 0x2029 (PARAGRAPH SEPARATOR) to directly appear in 字符型字面量 without using an escape sequence. This is enabled by using the following alternative definition of DoubleStringCharacter when parsing scriptText in step 4:

but not one of " or \ or U+0000 through U+001F

The SV of DoubleStringCharacter::SourceCharacterbut not one of " or \ or U+0000 through U+001F is the UTF16Encoding of the 码点 value of SourceCharacter.

Note

Valid JSON text is a subset of the ES PrimaryExpression syntax as modified by Step 4 above. Step 2 verifies that JText conforms to that subset, and step 6 verifies that that parsing and 估值 returns a value of an appropriate type.

24.5.1.1运行时语义: InternalizeJSONProperty( `holder`, `name` )

The 抽象操作 InternalizeJSONProperty is a recursive 抽象操作 that takes two parameters: a holder object and the String name of a property in that object. InternalizeJSONProperty uses the value of reviver that was originally passed to the above parse function.

Let val be ? Get(holder, name).
If Type(val) is Object, then
1. Let isArray be ? IsArray(val).
2. If isArray is true, then
  1. Let I be 0.
  2. Let len be ? ToLength(? Get(val, "length")).
  3. Repeat, while I < len,
    1. Let newElement be ? InternalizeJSONProperty(val, ! ToString(I)).
    2. If newElement is undefined, then
      1. Perform ? val.[[Delete]](! ToString(I)).
    3. Else,
      1. Perform ? CreateDataProperty(val, ! ToString(I), newElement).
      2. NOTE: This 算法 intentionally does not 抛出一个异常 if CreateDataProperty returns false.
    4. Add 1 to I.
3. Else,
  1. Let keys be ? EnumerableOwnPropertyNames(val, "key").
  2. For each String P in keys, do
    1. Let newElement be ? InternalizeJSONProperty(val, P).
    2. If newElement is undefined, then
      1. Perform ? val.[[Delete]](P).
    3. Else,
      1. Perform ? CreateDataProperty(val, P, newElement).
      2. NOTE: This 算法 intentionally does not 抛出一个异常 if CreateDataProperty returns false.
Return ? Call(reviver, holder, « name, val »).

It is not permitted for a conforming 实现 of JSON.parse to extend the JSON grammars. If an 实现 wishes to support a modified or extended JSON interchange format it must do so by defining a different parse function.

Note

In the case where there are duplicate name Strings within an object, lexically preceding values for the same key shall be overwritten.

24.5.2JSON.stringify ( `value` [ , `replacer` [ , `space` ] ] )

The stringify function returns a String in UTF-16 encoded JSON format representing an ES 值. It can take three parameters. The value parameter is an ES 值, which is usually an object or array, although it can also be a String, Boolean, Number or null. The optional replacer parameter is either a function that alters the way objects and arrays are stringified, or an array of Strings and Numbers that acts as an inclusion list for selecting the object properties that will be stringified. The optional space parameter is a String or Number that allows the result to have 空白 injected into it to improve human readability.

These are the steps in stringifying an object:

Let stack be a new empty List.
Let indent be the empty String.
Let PropertyList and ReplacerFunction be undefined.
If Type(replacer) is Object, then
1. If IsCallable(replacer) is true, then
  1. Let ReplacerFunction be replacer.
2. Else,
  1. Let isArray be ? IsArray(replacer).
  2. If isArray is true, then
    1. Let PropertyList be a new empty List.
    2. Let len be ? ToLength(? Get(replacer, "length")).
    3. Let k be 0.
    4. Repeat, while k<len,
      1. Let v be ? Get(replacer, ! ToString(k)).
      2. Let item be undefined.
      3. If Type(v) is String, let item be v.
      4. Else if Type(v) is Number, let item be ! ToString(v).
      5. Else if Type(v) is Object, then
        If v has a [[StringData]] or [[NumberData]] 内部属性, let item be ? ToString(v).
      6. If item is not undefined and item is not currently an element of PropertyList, then
        Append item to the end of PropertyList.
      7. Let k be k+1.
If Type(space) is Object, then
1. If space has a [[NumberData]] 内部属性, then
  1. Let space be ? ToNumber(space).
2. Else if space has a [[StringData]] 内部属性, then
  1. Let space be ? ToString(space).
If Type(space) is Number, then
1. Let space be min(10, ToInteger(space)).
2. Set gap to the String 值 containing space occurrences of the 代码单元 0x0020 (SPACE). This will be the empty String if space is less than 1.
Else if Type(space) is String, then
1. If the length of space is 10 or less, set gap to space; otherwise set gap to the String 值 consisting of the first 10 elements of space.
Else,
1. Set gap to the empty String.
Let wrapper be ObjectCreate(%ObjectPrototype%).
Let status be CreateDataProperty(wrapper, the empty String, value).
Assert: status is true.
Return ? SerializeJSONProperty(the empty String, wrapper).

The length property of the stringify function is 3.

Note 1

JSON structures are allowed to be nested to any depth, but they must be acyclic. If value is or contains a cyclic structure, then the stringify function must 抛出一个 TypeError 异常. This is an example of a value that cannot be stringified:

a = [];
              a[0] = a;
              my_text = JSON.stringify(a); // This must 抛出一个 TypeError.

Note 2

Symbolic primitive values are rendered as follows:

The null value is rendered in JSON text as the String null.
The undefined value is not rendered.
The true value is rendered in JSON text as the String true.
The false value is rendered in JSON text as the String false.

Note 3

String values are wrapped in QUOTATION MARK (") 代码单元. The 代码单元 " and \ are escaped with \ prefixes. Control characters 代码单元 are replaced with escape sequences \uHHHH, or with the shorter forms, \b (BACKSPACE), \f (FORM FEED), \n (LINE FEED), \r (CARRIAGE RETURN), \t (CHARACTER TABULATION).

Note 4

Finite numbers are stringified as if by calling ToString(number). NaN and Infinity regardless of sign are represented as the String null.

Note 5

Values that do not have a JSON representation (例如 undefined and functions) do not produce a String. Instead they produce the undefined value. In arrays these values are represented as the String null. In objects an unrepresentable value causes the property to be excluded from stringification.

Note 6

An object is rendered as U+007B (LEFT CURLY BRACKET) followed by zero or more properties, separated with a U+002C (COMMA), closed with a U+007D (RIGHT CURLY BRACKET). A property is a quoted String representing the key or 属性名, a U+003A (COLON), and then the stringified property value. An array is rendered as an opening U+005B (LEFT SQUARE BRACKET followed by zero or more values, separated with a U+002C (COMMA), closed with a U+005D (RIGHT SQUARE BRACKET).

24.5.2.1运行时语义: SerializeJSONProperty ( `key`, `holder` )

The 抽象操作 SerializeJSONProperty with arguments key, and holder has access to ReplacerFunction from the invocation of the stringify method. Its 算法 is as follows:

Let value be ? Get(holder, key).
If Type(value) is Object, then
1. Let toJSON be ? Get(value, "toJSON").
2. If IsCallable(toJSON) is true, then
  1. Set value to ? Call(toJSON, value, « key »).
If ReplacerFunction is not undefined, then
1. Set value to ? Call(ReplacerFunction, holder, « key, value »).
If Type(value) is Object, then
1. If value has a [[NumberData]] 内部属性, then
  1. Set value to ? ToNumber(value).
2. Else if value has a [[StringData]] 内部属性, then
  1. Set value to ? ToString(value).
3. Else if value has a [[BooleanData]] 内部属性, then
  1. Set value to value.[[BooleanData]].
If value is null, return "null".
If value is true, return "true".
If value is false, return "false".
If Type(value) is String, return QuoteJSONString(value).
If Type(value) is Number, then
1. If value is finite, return ! ToString(value).
2. Return "null".
If Type(value) is Object and IsCallable(value) is false, then
1. Let isArray be ? IsArray(value).
2. If isArray is true, return ? SerializeJSONArray(value).
3. Return ? SerializeJSONObject(value).
Return undefined.

24.5.2.2运行时语义: QuoteJSONString ( `value` )

The 抽象操作 QuoteJSONString with argument value wraps a String 值 in QUOTATION MARK 代码单元 and escapes certain other 代码单元 within it.

Let product be the String 值 consisting solely of the 代码单元 0x0022 (QUOTATION MARK).

For each 代码单元 C in value, do

If C is the 代码单元 0x0022 (QUOTATION MARK) or the 代码单元 0x005C (REVERSE SOLIDUS), then
1. Set product to the string-concatenation of product and the 代码单元 0x005C (REVERSE SOLIDUS).
2. Set product to the string-concatenation of product and C.

Else if C is the 代码单元 0x0008 (BACKSPACE), the 代码单元 0x000C (FORM FEED), the 代码单元 0x000A (LINE FEED), the 代码单元 0x000D (CARRIAGE RETURN), or the 代码单元 0x0009 (CHARACTER TABULATION), then

Set product to the string-concatenation of product and the 代码单元 0x005C (REVERSE SOLIDUS).

Let abbrev be the String 值 corresponding to the value of C as follows:

BACKSPACE	`"b"`
FORM FEED (FF)	`"f"`
LINE FEED (LF)	`"n"`
CARRIAGE RETURN (CR)	`"r"`
CHARACTER TABULATION	`"t"`

Set product to the string-concatenation of product and abbrev.

Else if C has a 数字值 less than 0x0020 (SPACE), then
1. Set product to the string-concatenation of product and the 代码单元 0x005C (REVERSE SOLIDUS).
2. Set product to the string-concatenation of product and "u".
3. Let hex be the string result of converting the 数字值 of C to a String of four lowercase hexadecimal digits.
4. Set product to the string-concatenation of product and hex.
Else,
1. Set product to the string-concatenation of product and C.

Set product to the string-concatenation of product and the 代码单元 0x0022 (QUOTATION MARK).
Return product.

24.5.2.3运行时语义: SerializeJSONObject ( `value` )

The 抽象操作 SerializeJSONObject with argument value serializes an object. It has access to the stack, indent, gap, and PropertyList values of the current invocation of the stringify method.

If stack contains value, 抛出一个 TypeError 异常 because the structure is cyclical.
Append value to stack.
Let stepback be indent.
Set indent to the string-concatenation of indent and gap.
If PropertyList is not undefined, then
1. Let K be PropertyList.
Else,
1. Let K be ? EnumerableOwnPropertyNames(value, "key").
Let partial be a new empty List.
For each element P of K, do
1. Let strP be ? SerializeJSONProperty(P, value).
2. If strP is not undefined, then
  1. Let member be QuoteJSONString(P).
  2. Set member to the string-concatenation of member and ":".
  3. If gap is not the empty String, then
    1. Set member to the string-concatenation of member and the 代码单元 0x0020 (SPACE).
  4. Set member to the string-concatenation of member and strP.
  5. Append member to partial.
If partial is empty, then
1. Let final be "{}".
Else,
1. If gap is the empty String, then
  1. Let properties be the String 值 formed by concatenating all the element Strings of partial with each adjacent pair of Strings separated with the 代码单元 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
  2. Let final be the string-concatenation of "{", properties, and "}".
2. Else gap is not the empty String,
  1. Let separator be the string-concatenation of the 代码单元 0x002C (COMMA), the 代码单元 0x000A (LINE FEED), and indent.
  2. Let properties be the String 值 formed by concatenating all the element Strings of partial with each adjacent pair of Strings separated with separator. The separator String is not inserted either before the first String or after the last String.
  3. Let final be the string-concatenation of "{", the 代码单元 0x000A (LINE FEED), indent, properties, the 代码单元 0x000A (LINE FEED), stepback, and "}".
Remove the last element of stack.
Set indent to stepback.
Return final.

24.5.2.4运行时语义: SerializeJSONArray ( `value` )

The 抽象操作 SerializeJSONArray with argument value serializes an array. It has access to the stack, indent, and gap values of the current invocation of the stringify method.

If stack contains value, 抛出一个 TypeError 异常 because the structure is cyclical.
Append value to stack.
Let stepback be indent.
Set indent to the string-concatenation of indent and gap.
Let partial be a new empty List.
Let len be ? ToLength(? Get(value, "length")).
Let index be 0.
Repeat, while index < len
1. Let strP be ? SerializeJSONProperty(! ToString(index), value).
2. If strP is undefined, then
  1. Append "null" to partial.
3. Else,
  1. Append strP to partial.
4. Increment index by 1.
If partial is empty, then
1. Let final be "[]".
Else,
1. If gap is the empty String, then
  1. Let properties be the String 值 formed by concatenating all the element Strings of partial with each adjacent pair of Strings separated with the 代码单元 0x002C (COMMA). A comma is not inserted either before the first String or after the last String.
  2. Let final be the string-concatenation of "[", properties, and "]".
2. Else,
  1. Let separator be the string-concatenation of the 代码单元 0x002C (COMMA), the 代码单元 0x000A (LINE FEED), and indent.
  2. Let properties be the String 值 formed by concatenating all the element Strings of partial with each adjacent pair of Strings separated with separator. The separator String is not inserted either before the first String or after the last String.
  3. Let final be the string-concatenation of "[", the 代码单元 0x000A (LINE FEED), indent, properties, the 代码单元 0x000A (LINE FEED), stepback, and "]".
Remove the last element of stack.
Set indent to stepback.
Return final.

Note

The representation of arrays includes only the elements between zero and array.length - 1 inclusive. Properties whose keys are not array indexes are excluded from the stringification. An array is stringified as an opening LEFT SQUARE BRACKET, elements separated by COMMA, and a closing RIGHT SQUARE BRACKET.

24.5.3JSON [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "JSON".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25控制抽象对象

25.1Iteration

25.1.1Common Iteration Interfaces

An interface is a set of 属性键 whose associated values match a specific specification. Any object that provides all the properties as described by an interface's specification conforms to that interface. An interface is not represented by a distinct object. There may be many separately implemented objects that conform to any interface. An individual object may conform to multiple interfaces.

25.1.1.1The Iterable Interface

The Iterable interface includes the property described in Table 59:

Table 59: Iterable Interface Required Properties

Property	Value	Requirements
`@@迭代器`	A function that returns an 迭代器 object.	The returned object must conform to the 迭代器 interface.

25.1.1.2The 迭代器 Interface

An object that implements the 迭代器 interface must include the property in Table 60. Such objects may also implement the properties in Table 61.

Table 60: 迭代器 Interface Required Properties

Property	Value	Requirements
`next`	A function that returns an IteratorResult object.	The returned object must conform to the IteratorResult interface. If a previous call to the `next` method of an 迭代器 has returned an IteratorResult object whose `done` property is true, then all subsequent calls to the `next` method of that object should also return an IteratorResult object whose `done` property is true. However, this requirement is not enforced.

Note 1

Arguments may be passed to the next function but their interpretation and validity is dependent upon the target 迭代器. The for-of statement and other common users of Iterators do not pass any arguments, so 迭代器 objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.

Table 61: 迭代器 Interface Optional Properties

Property	Value	Requirements
`return`	A function that returns an IteratorResult object.	The returned object must conform to the IteratorResult interface. Invoking this method notifies the 迭代器 object that the caller does not intend to make any more `next` method calls to the 迭代器. The returned IteratorResult object will typically have a `done` property whose value is true, and a `value` property with the value passed as the argument of the `return` method. However, this requirement is not enforced.
`throw`	A function that returns an IteratorResult object.	The returned object must conform to the IteratorResult interface. Invoking this method notifies the 迭代器 object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an 异常 object. A typical response is to `throw` the value passed as the argument. If the method does not `throw`, the returned IteratorResult object will typically have a `done` property whose value is true.

Note 2

Typically callers of these methods should check for their existence before invoking them. Certain ES language features including for-of, yield*, and array destructuring call these methods after performing an existence check. Most ES library functions that accept Iterable objects as arguments also conditionally call them.

25.1.1.3The AsyncIterable Interface

The AsyncIterable interface includes the properties described in Table 62:

Table 62: AsyncIterable Interface Required Properties

Property	Value	Requirements
`@@asyncIterator`	A function that returns an AsyncIterator object.	The returned object must conform to the AsyncIterator interface.

25.1.1.4The AsyncIterator Interface

An object that implements the AsyncIterator interface must include the properties in Table 63. Such objects may also implement the properties in Table 64.

Table 63: AsyncIterator Interface Required Properties

Property Value Requirements

next

A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. If a previous call to the next method of an AsyncIterator has returned a promise for an IteratorResult object whose done property is true, then all subsequent calls to the next method of that object should also return a promise for an IteratorResult object whose done property is true. However, this requirement is not enforced.

Additionally, the IteratorResult object that serves as a fulfillment value should have a value property whose value is not a promise (or "thenable"). However, this requirement is also not enforced.

Note 1

Arguments may be passed to the next function but their interpretation and validity is dependent upon the target AsyncIterator. The for-await-of statement and other common users of AsyncIterators do not pass any arguments, so AsyncIterator objects that expect to be used in such a manner must be prepared to deal with being called with no arguments.

Table 64: AsyncIterator Interface Optional Properties

Property Value Requirements

return

A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. Invoking this method notifies the AsyncIterator object that the caller does not intend to make any more next method calls to the AsyncIterator. The returned promise will fulfill with an IteratorResult object which will typically have a done property whose value is true, and a value property with the value passed as the argument of the return method. However, this requirement is not enforced.

Additionally, the IteratorResult object that serves as a fulfillment value should have a value property whose value is not a promise (or "thenable"). If the argument value is used in the typical manner, then if it is a rejected promise, a promise rejected with the same reason should be returned; if it is a fulfilled promise, then its fulfillment value should be used as the value property of the returned promise's IteratorResult object fulfillment value. However, these requirements are also not enforced.

throw

A function that returns a promise for an IteratorResult object.

The returned promise, when fulfilled, must fulfill with an object which conforms to the IteratorResult interface. Invoking this method notifies the AsyncIterator object that the caller has detected an error condition. The argument may be used to identify the error condition and typically will be an 异常 object. A typical response is to return a rejected promise which rejects with the value passed as the argument.

If the returned promise is fulfilled, the IteratorResult fulfillment value will typically have a done property whose value is true. Additionally, it should have a value property whose value is not a promise (or "thenable"), but this requirement is not enforced.

Note 2

Typically callers of these methods should check for their existence before invoking them. Certain ES language features including for-await-of and yield* call these methods after performing an existence check.

25.1.1.5The IteratorResult Interface

The IteratorResult interface includes the properties listed in Table 65:

Table 65: IteratorResult Interface Properties

Property	Value	Requirements
`done`	Either true or false.	This is the result status of an 迭代器 `next` method call. If the end of the 迭代器 was reached `done` is true. If the end was not reached `done` is false and a value is available. If a `done` property (either own or inherited) does not exist, it is consider to have the value false.
`value`	Any ES 语言值.	If done is false, this is the current iteration element value. If done is true, this is the 返回值 of the 迭代器, if it supplied one. If the 迭代器 does not have a 返回值, `value` is undefined. In that case, the `value` property may be absent from the conforming object if it does not inherit an explicit `value` property.

25.1.2The %IteratorPrototype% Object

[[Prototype]] 内部属性的值 of the %IteratorPrototype% object is the 内部对象 %ObjectPrototype%. The %IteratorPrototype% object is an 普通对象. The 初始值 of the [[Extensible]] 内部属性 of the %IteratorPrototype% object is true.

Note

所有定义在本规范中的对象 that implement the 迭代器 interface also inherit from %IteratorPrototype%. ES 代码 may also define objects that inherit from %IteratorPrototype%.The %IteratorPrototype% object provides a place where additional methods that are applicable to all 迭代器对象 may be added.

The following expression is one way that ES 代码 can access the %IteratorPrototype% object:

Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.迭代器]()))

25.1.2.1%IteratorPrototype% [ @@迭代器 ] ( )

执行如下:

Return the this value.

The value of the name property of this function is "[Symbol.迭代器]".

25.1.3The %AsyncIteratorPrototype% Object

[[Prototype]] 内部属性的值 of the %AsyncIteratorPrototype% object is the 内部对象 %ObjectPrototype%. The %AsyncIteratorPrototype% object is an 普通对象. The 初始值 of the [[Extensible]] 内部属性 of the %AsyncIteratorPrototype% object is true.

Note

所有定义在本规范中的对象 that implement the AsyncIterator interface also inherit from %AsyncIteratorPrototype%. ES 代码 may also define objects that inherit from %AsyncIteratorPrototype%.The %AsyncIteratorPrototype% object provides a place where additional methods that are applicable to all async 迭代器对象 may be added.

25.1.3.1%AsyncIteratorPrototype% [ @@asyncIterator ] ( )

执行如下:

Return the this value.

The value of the name property of this function is "[Symbol.asyncIterator]".

25.1.4Async-from-Sync 迭代器对象

An Async-from-Sync 迭代器 object is an async 迭代器 that adapts a specific synchronous 迭代器. There is not a named 构造器 for Async-from-Sync 迭代器对象. Instead, Async-from-Sync 迭代器对象 are created by the CreateAsyncFromSyncIterator 抽象操作 as needed.

25.1.4.1CreateAsyncFromSyncIterator ( `syncIteratorRecord` )

The 抽象操作 CreateAsyncFromSyncIterator is used to create an async 迭代器 Record from a synchronous 迭代器 Record. It 执行如下:

Let asyncIterator be ! ObjectCreate(%AsyncFromSyncIteratorPrototype%, « [[SyncIteratorRecord]] »).
Set asyncIterator.[[SyncIteratorRecord]] to syncIteratorRecord.
Return ? GetIterator(asyncIterator, async).

25.1.4.2The %AsyncFromSyncIteratorPrototype% Object

All Async-from-Sync 迭代器对象继承属性 from the %AsyncFromSyncIteratorPrototype% 内部对象. The %AsyncFromSyncIteratorPrototype% object is an 普通对象 and its [[Prototype]] 内部属性 is the %AsyncIteratorPrototype% 内部对象. In addition, %AsyncFromSyncIteratorPrototype% 有以下属性:

25.1.4.2.1%AsyncFromSyncIteratorPrototype%.next ( `value` )

Let O be the this value.
Let promiseCapability be ! NewPromiseCapability(%Promise%).
If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] 内部属性, then
1. Let invalidIteratorError be a newly created TypeError object.
2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
3. Return promiseCapability.[[Promise]].
Let syncIteratorRecord be O.[[SyncIteratorRecord]].
Let nextResult be IteratorNext(syncIteratorRecord, value).
IfAbruptRejectPromise(nextResult, promiseCapability).
Let nextDone be IteratorComplete(nextResult).
IfAbruptRejectPromise(nextDone, promiseCapability).
Let nextValue be IteratorValue(nextResult).
IfAbruptRejectPromise(nextValue, promiseCapability).
Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « nextValue »).
Let steps be the 算法步骤 defined in Async-from-Sync 迭代器 Value Unwrap Functions.
Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
Set onFulfilled.[[Done]] to nextDone.
Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
Return promiseCapability.[[Promise]].

25.1.4.2.2%AsyncFromSyncIteratorPrototype%.return ( `value` )

Let O be the this value.
Let promiseCapability be ! NewPromiseCapability(%Promise%).
If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] 内部属性, then
1. Let invalidIteratorError be a newly created TypeError object.
2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
3. Return promiseCapability.[[Promise]].
Let syncIterator be O.[[SyncIteratorRecord]].[[迭代器]].
Let return be GetMethod(syncIterator, "return").
IfAbruptRejectPromise(return, promiseCapability).
If return is undefined, then
1. Let iterResult be ! CreateIterResultObject(value, true).
2. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »).
3. Return promiseCapability.[[Promise]].
Let returnResult be Call(return, syncIterator, « value »).
IfAbruptRejectPromise(returnResult, promiseCapability).
If Type(returnResult) is not Object, then
1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
2. Return promiseCapability.[[Promise]].
Let returnDone be IteratorComplete(returnResult).
IfAbruptRejectPromise(returnDone, promiseCapability).
Let returnValue be IteratorValue(returnResult).
IfAbruptRejectPromise(returnValue, promiseCapability).
Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « returnValue »).
Let steps be the 算法步骤 defined in Async-from-Sync 迭代器 Value Unwrap Functions.
Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
Set onFulfilled.[[Done]] to returnDone.
Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
Return promiseCapability.[[Promise]].

25.1.4.2.3%AsyncFromSyncIteratorPrototype%.throw ( `value` )

Let O be the this value.
Let promiseCapability be ! NewPromiseCapability(%Promise%).
If Type(O) is not Object, or if O does not have a [[SyncIteratorRecord]] 内部属性, then
1. Let invalidIteratorError be a newly created TypeError object.
2. Perform ! Call(promiseCapability.[[Reject]], undefined, « invalidIteratorError »).
3. Return promiseCapability.[[Promise]].
Let syncIterator be O.[[SyncIteratorRecord]].[[迭代器]].
Let throw be GetMethod(syncIterator, "throw").
IfAbruptRejectPromise(throw, promiseCapability).
If throw is undefined, then
1. Perform ! Call(promiseCapability.[[Reject]], undefined, « value »).
2. Return promiseCapability.[[Promise]].
Let throwResult be Call(throw, syncIterator, « value »).
IfAbruptRejectPromise(throwResult, promiseCapability).
If Type(throwResult) is not Object, then
1. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »).
2. Return promiseCapability.[[Promise]].
Let throwDone be IteratorComplete(throwResult).
IfAbruptRejectPromise(throwDone, promiseCapability).
Let throwValue be IteratorValue(throwResult).
IfAbruptRejectPromise(throwValue, promiseCapability).
Let valueWrapperCapability be ! NewPromiseCapability(%Promise%).
Perform ! Call(valueWrapperCapability.[[Resolve]], undefined, « throwValue »).
Let steps be the 算法步骤 defined in Async-from-Sync 迭代器 Value Unwrap Functions.
Let onFulfilled be CreateBuiltinFunction(steps, « [[Done]] »).
Set onFulfilled.[[Done]] to throwDone.
Perform ! PerformPromiseThen(valueWrapperCapability.[[Promise]], onFulfilled, undefined, promiseCapability).
Return promiseCapability.[[Promise]].

25.1.4.2.4%AsyncFromSyncIteratorPrototype% [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Async-from-Sync 迭代器".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.1.4.2.5Async-from-Sync 迭代器 Value Unwrap Functions

An async-from-sync 迭代器 value unwrap function is an anonymous 内置函数 that is used by methods of %AsyncFromSyncIteratorPrototype% when processing the value field of an IteratorResult object, in order to wait for its value if it is a promise and re-package the result in a new "unwrapped" IteratorResult object. Each async 迭代器 value unwrap function has a [[Done]] 内部属性.

When an async-from-sync 迭代器 value unwrap function F is called with argument value, 执行如下:

Return ! CreateIterResultObject(value, F.[[Done]]).

25.1.4.3Properties of Async-from-Sync 迭代器实例

Async-from-Sync 迭代器实例 are 普通对象 that 继承属性 from the %AsyncFromSyncIteratorPrototype% 内部对象. Async-from-Sync 迭代器实例 are initially created with the 内部属性 listed in Table 66.

Table 66: 内部属性 of Async-from-Sync 迭代器实例

内部属性	Description
[[SyncIteratorRecord]]	A Record, of the type returned by GetIterator, representing the original synchronous 迭代器 which is being adapted.

25.2生成器函数对象

生成器函数对象 are functions that are usually created by evaluating GeneratorDeclarations, GeneratorExpressions, and GeneratorMethods. They may also be created by calling the %GeneratorFunction% intrinsic.

A staggering variety of boxes and arrows. — Figure 5 (Informative): 生成器对象 Relationships

25.2.1生成器函数构造器

The GeneratorFunction 构造器 is the %GeneratorFunction% intrinsic. When GeneratorFunction 被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 GeneratorFunction object. Thus the function call GeneratorFunction (…) is equivalent to the object creation expression new GeneratorFunction (…) with the same arguments.

GeneratorFunction 被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 GeneratorFunction behaviour must include a super call to the GeneratorFunction 构造器 to create and initialize subclass instances with the 内部属性 necessary for 内置 GeneratorFunction behaviour. All ES syntactic forms for defining generator 函数对象 create direct instances of GeneratorFunction. There is no syntactic means to create instances of GeneratorFunction subclasses.

25.2.1.1GeneratorFunction ( `p1`, `p2`, … , `pn`, `body` )

The last argument specifies the body (executable code) of a 生成器函数; any preceding arguments specify formal parameters.

When the GeneratorFunction function is called with some arguments p1, p2, … , pn, body (where n might be 0, that is, there are no “p” arguments, and where body might also not be provided), 执行如下:

Let C be the active 函数对象.
Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
Return ? CreateDynamicFunction(C, NewTarget, "generator", args).

Note

See NOTE for 19.2.1.1.

25.2.2生成器函数构造器的属性

The GeneratorFunction 构造器 is a 标准内置函数对象 that inherits from the Function 构造器. [[Prototype]] 内部属性的值 of the GeneratorFunction 构造器 is the 内部对象 %Function%.

The value of the [[Extensible]] 内部属性 of the GeneratorFunction 构造器 is true.

The value of the name property of the GeneratorFunction is "GeneratorFunction".

The GeneratorFunction 构造器有以下属性:

25.2.2.1GeneratorFunction.length

This is a 数据属性 with a value of 1. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.2.2GeneratorFunction.prototype

The 初始值 of GeneratorFunction.prototype is the 内部对象 %Generator%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.2.3生成器函数原型对象的属性

The GeneratorFunction 原型对象 is an 普通对象. It is not a 函数对象 and does not have an [[ECMAScriptCode]] 内部属性 or any other of the 内部属性 listed in Table 27 or Table 67. In addition to being the value of the prototype property of the %GeneratorFunction% intrinsic, it is the %Generator% intrinsic (see Figure 2).

[[Prototype]] 内部属性的值 of the GeneratorFunction 原型对象 is the %FunctionPrototype% 内部对象. The 初始值 of the [[Extensible]] 内部属性 of the GeneratorFunction 原型对象 is true.

25.2.3.1GeneratorFunction.prototype.constructor

The 初始值 of GeneratorFunction.prototype.constructor is the 内部对象 %GeneratorFunction%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.3.2GeneratorFunction.prototype.prototype

The value of GeneratorFunction.prototype.prototype is the %GeneratorPrototype% 内部对象.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.3.3GeneratorFunction.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "GeneratorFunction".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.2.4生成器函数实例

Every GeneratorFunction instance is an ES 函数对象 and has the 内部属性 listed in Table 27. The value of the [[FunctionKind]] 内部属性 for all such instances is "generator".

Each GeneratorFunction instance 拥有以下自身属性:

25.2.4.1length

The specification for the length property of 函数实例 given in 19.2.4.1 also applies to 生成器函数实例.

25.2.4.2name

The specification for the name property of 函数实例 given in 19.2.4.2 also applies to 生成器函数实例.

25.2.4.3prototype

Whenever a GeneratorFunction instance is created another 普通对象 is also created and is the 初始值 of the 生成器函数's prototype property. The value of the prototype property is used to initialize the [[Prototype]] 内部属性 of a newly created 生成器对象 when the generator 函数对象 is invoked using [[Call]].

该属性拥有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Unlike 函数实例, the object that is the value of the a GeneratorFunction's prototype property does not have a 构造器 property whose value is the GeneratorFunction instance.

25.3异步生成器函数对象

异步生成器函数对象 are functions that are usually created by evaluating AsyncGeneratorDeclaration, AsyncGeneratorExpression, and AsyncGeneratorMethod syntactic productions. They may also be created by calling the %AsyncGeneratorFunction% intrinsic.

25.3.1异步生成器函数构造器

The AsyncGeneratorFunction 构造器 is the %AsyncGeneratorFunction% intrinsic. When AsyncGeneratorFunction 被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 AsyncGeneratorFunction object. Thus the function call AsyncGeneratorFunction (...) is equivalent to the object creation expression new AsyncGeneratorFunction (...) with the same arguments.

AsyncGeneratorFunction 被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 AsyncGeneratorFunction behaviour must include a super call to the AsyncGeneratorFunction 构造器 to create and initialize subclass instances with the 内部属性 necessary for 内置 AsyncGeneratorFunction behaviour. All ES syntactic forms for defining async generator 函数对象 create direct instances of AsyncGeneratorFunction. There is no syntactic means to create instances of AsyncGeneratorFunction subclasses.

25.3.1.1AsyncGeneratorFunction ( `p1`, `p2`, ..., `pn`, `body` )

The last argument specifies the body (executable code) of an async 生成器函数; any preceding arguments specify formal parameters.

When the AsyncGeneratorFunction function is called with some arguments p1, p2, … , pn, body (where n might be 0, that is, there are no "p" arguments, and where body might also not be provided), 执行如下:

Let C be the active 函数对象.
Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
Return ? CreateDynamicFunction(C, NewTarget, "async generator", args).

Note

See NOTE for 19.2.1.1.

25.3.2异步生成器函数构造器的属性

The AsyncGeneratorFunction 构造器 is a 标准内置函数对象 that inherits from the Function 构造器. [[Prototype]] 内部属性的值 of the AsyncGeneratorFunction 构造器 is the 内部对象 %Function%.

The value of the [[Extensible]] 内部属性 of the AsyncGeneratorFunction 构造器 is true.

The value of the name property of the AsyncGeneratorFunction is "AsyncGeneratorFunction".

The AsyncGeneratorFunction 构造器有以下属性:

25.3.2.1AsyncGeneratorFunction.length

This is a 数据属性 with a value of 1. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.2.2AsyncGeneratorFunction.prototype

The 初始值 of AsyncGeneratorFunction.prototype is the 内部对象 %AsyncGenerator%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.3.3异步生成器函数原型对象的属性

The AsyncGeneratorFunction 原型对象 is an 普通对象. It is not a 函数对象 and does not have an [[ECMAScriptCode]] 内部属性 or any other of the 内部属性 listed in Table 27 or Table 68. In addition to being the value of the prototype property of the %AsyncGeneratorFunction% intrinsic, it is the %AsyncGenerator% intrinsic.

[[Prototype]] 内部属性的值 of the AsyncGeneratorFunction 原型对象 is the %FunctionPrototype% 内部对象. The 初始值 of the [[Extensible]] 内部属性 of the AsyncGeneratorFunction 原型对象 is true.

25.3.3.1AsyncGeneratorFunction.prototype.constructor

The 初始值 of AsyncGeneratorFunction.prototype.constructor is the 内部对象 %AsyncGeneratorFunction%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.3.2AsyncGeneratorFunction.prototype.prototype

The value of AsyncGeneratorFunction.prototype.prototype is the %AsyncGeneratorPrototype% 内部对象.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.3.3AsyncGeneratorFunction.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "AsyncGeneratorFunction".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.4异步生成器函数实例

Every AsyncGeneratorFunction instance is an ES 函数对象 and has the 内部属性 listed in Table 27. The value of the [[FunctionKind]] 内部属性 for all such instances is "generator".

Each AsyncGeneratorFunction instance 拥有以下自身属性:

25.3.4.1length

The value of the length property is an integer that indicates the typical number of arguments expected by the AsyncGeneratorFunction. However, the language permits the function to be invoked with some other number of arguments. The behaviour of an AsyncGeneratorFunction when invoked on a number of arguments other than the number specified by its length property depends on the function.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.3.4.2name

The specification for the name property of 函数实例 given in 19.2.4.2 also applies to 异步生成器函数实例.

25.3.4.3prototype

Whenever an AsyncGeneratorFunction instance is created another 普通对象 is also created and is the 初始值 of the async 生成器函数's prototype property. The value of the prototype property is used to initialize the [[Prototype]] 内部属性 of a newly created AsyncGenerator object when the generator 函数对象 is invoked using [[Call]].

该属性拥有特性 { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.

Note

Unlike 函数实例, the object that is the value of the an AsyncGeneratorFunction's prototype property does not have a 构造器 property whose value is the AsyncGeneratorFunction instance.

25.4生成器对象

A 生成器对象 is an instance of a 生成器函数 and conforms to both the 迭代器 and Iterable interfaces.

生成器实例 directly 继承属性 from the object that is the value of the prototype property of the 生成器函数 that created the instance. 生成器实例 indirectly 继承属性 from the Generator Prototype intrinsic, %GeneratorPrototype%.

25.4.1生成器原型的属性

The Generator 原型对象 is the %GeneratorPrototype% intrinsic. It is also the 初始值 of the prototype property of the %Generator% intrinsic (the GeneratorFunction.prototype).

The Generator prototype is an 普通对象. It is not a Generator instance and does not have a [[GeneratorState]] 内部属性.

[[Prototype]] 内部属性的值 of the Generator 原型对象 is the 内部对象 %IteratorPrototype%. The 初始值 of the [[Extensible]] 内部属性 of the Generator 原型对象 is true.

All 生成器实例 indirectly 继承属性 of the Generator 原型对象.

25.4.1.1Generator.prototype.constructor

The 初始值 of Generator.prototype.constructor is the 内部对象 %Generator%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.4.1.2Generator.prototype.next ( `value` )

The next method 执行如下:

Let g be the this value.
Return ? GeneratorResume(g, value).

25.4.1.3Generator.prototype.return ( `value` )

The return method 执行如下:

Let g be the this value.
Let C be Completion{[[Type]]: return, [[Value]]: value, [[Target]]: empty}.
Return ? GeneratorResumeAbrupt(g, C).

25.4.1.4Generator.prototype.throw ( `异常` )

The throw method 执行如下:

Let g be the this value.
Let C be Completion{[[Type]]: throw, [[Value]]: 异常, [[Target]]: empty}.
Return ? GeneratorResumeAbrupt(g, C).

25.4.1.5Generator.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Generator".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.4.2生成器实例的属性

生成器实例 are initially created with the 内部属性 described in Table 67.

Table 67: 内部属性 of 生成器实例

内部属性	Description
[[GeneratorState]]	The current execution state of the generator. The possible values are: undefined, `"suspendedStart"`, `"suspendedYield"`, `"executing"`, and `"completed"`.
[[GeneratorContext]]	The 执行上下文 that is used when executing the code of this generator.

25.4.3生成器抽象操作

25.4.3.1GeneratorStart ( `generator`, `generatorBody` )

The 抽象操作 GeneratorStart with arguments generator and generatorBody 执行如下:

Assert: The value of generator.[[GeneratorState]] is undefined.
Let genContext be the 运行时执行上下文.
Set the Generator component of genContext to generator.
Set the code 估值 state of genContext such that when 估值 is resumed for that 执行上下文 the following steps will be performed:
1. Let result be the result of evaluating generatorBody.
2. Assert: If we return here, the generator either threw an 异常 or performed either an implicit or explicit return.
3. Remove genContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
4. Set generator.[[GeneratorState]] to "completed".
5. Once a generator enters the "completed" state it never leaves it and its associated 执行上下文 is never resumed. Any execution state associated with generator can be discarded at this point.
6. If result.[[Type]] is normal, let resultValue be undefined.
7. Else if result.[[Type]] is return, let resultValue be result.[[Value]].
8. Else,
  1. Assert: result.[[Type]] is throw.
  2. Return Completion(result).
9. Return CreateIterResultObject(resultValue, true).
Set generator.[[GeneratorContext]] to genContext.
Set generator.[[GeneratorState]] to "suspendedStart".
Return NormalCompletion(undefined).

25.4.3.2GeneratorValidate ( `generator` )

The 抽象操作 GeneratorValidate with argument generator 执行如下:

If Type(generator) is not Object, 抛出一个 TypeError 异常.
If generator does not have a [[GeneratorState]] 内部属性, 抛出一个 TypeError 异常.
Assert: generator also has a [[GeneratorContext]] 内部属性.
Let state be generator.[[GeneratorState]].
If state is "executing", 抛出一个 TypeError 异常.
Return state.

25.4.3.3GeneratorResume ( `generator`, `value` )

The 抽象操作 GeneratorResume with arguments generator and value 执行如下:

Let state be ? GeneratorValidate(generator).
If state is "completed", return CreateIterResultObject(undefined, true).
Assert: state is either "suspendedStart" or "suspendedYield".
Let genContext be generator.[[GeneratorContext]].
Let methodContext be the 运行时执行上下文.
Suspend methodContext.
Set generator.[[GeneratorState]] to "executing".
Push genContext onto the 执行上下文堆栈; genContext is now the 运行时执行上下文.
Resume the suspended 估值 of genContext using NormalCompletion(value) as the result of the operation that suspended it. Let result be the value returned by the resumed computation.
Assert: When we return here, genContext has already been removed from the 执行上下文堆栈 and methodContext is the currently 运行时执行上下文.
Return Completion(result).

25.4.3.4GeneratorResumeAbrupt ( `generator`, `abruptCompletion` )

The 抽象操作 GeneratorResumeAbrupt with arguments generator and abruptCompletion 执行如下:

Let state be ? GeneratorValidate(generator).
If state is "suspendedStart", then
1. Set generator.[[GeneratorState]] to "completed".
2. Once a generator enters the "completed" state it never leaves it and its associated 执行上下文 is never resumed. Any execution state associated with generator can be discarded at this point.
3. Set state to "completed".
If state is "completed", then
1. If abruptCompletion.[[Type]] is return, then
  1. Return CreateIterResultObject(abruptCompletion.[[Value]], true).
2. Return Completion(abruptCompletion).
Assert: state is "suspendedYield".
Let genContext be generator.[[GeneratorContext]].
Let methodContext be the 运行时执行上下文.
Suspend methodContext.
Set generator.[[GeneratorState]] to "executing".
Push genContext onto the 执行上下文堆栈; genContext is now the 运行时执行上下文.
Resume the suspended 估值 of genContext using abruptCompletion as the result of the operation that suspended it. Let result be the 完成记录 returned by the resumed computation.
Assert: When we return here, genContext has already been removed from the 执行上下文堆栈 and methodContext is the currently 运行时执行上下文.
Return Completion(result).

25.4.3.5GetGeneratorKind ( )

Let genContext be the 运行时执行上下文.
If genContext does not have a Generator component, return non-generator.
Let generator be the Generator component of genContext.
If generator has an [[AsyncGeneratorState]] 内部属性, return async.
Else, return sync.

25.4.3.6GeneratorYield ( `iterNextObj` )

The 抽象操作 GeneratorYield with argument iterNextObj 执行如下:

Assert: iterNextObj is an Object that implements the IteratorResult interface.
Let genContext be the 运行时执行上下文.
Assert: genContext is the 执行上下文 of a generator.
Let generator be the value of the Generator component of genContext.
Assert: GetGeneratorKind() is sync.
Set generator.[[GeneratorState]] to "suspendedYield".
Remove genContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
Set the code 估值 state of genContext such that when 估值 is resumed with a Completion resumptionValue the following steps will be performed:
1. Return resumptionValue.
2. NOTE: This returns to the 估值 of the YieldExpression that originally called this 抽象操作.
Return NormalCompletion(iterNextObj).
NOTE: This returns to the 估值 of the operation that had most previously resumed 估值 of genContext.

25.5异步生成器对象

An AsyncGenerator object is an instance of an async 生成器函数 and conforms to both the AsyncIterator and AsyncIterable interfaces.

AsyncGenerator instances directly 继承属性 from the object that is the value of the prototype property of the AsyncGenerator function that created the instance. AsyncGenerator instances indirectly 继承属性 from the AsyncGenerator Prototype intrinsic, %AsyncGeneratorPrototype%.

25.5.1异步生成器原型的属性

The AsyncGenerator 原型对象 is the %AsyncGeneratorPrototype% intrinsic. It is also the 初始值 of the prototype property of the %AsyncGenerator% intrinsic (the AsyncGeneratorFunction.prototype).

The AsyncGenerator prototype is an 普通对象. It is not an AsyncGenerator instance and does not have an [[AsyncGeneratorState]] 内部属性.

[[Prototype]] 内部属性的值 of the AsyncGenerator 原型对象 is the 内部对象 %AsyncIteratorPrototype%. The 初始值 of the [[Extensible]] 内部属性 of the AsyncGenerator 原型对象 is true.

All AsyncGenerator instances indirectly 继承属性 of the AsyncGenerator 原型对象.

25.5.1.1AsyncGenerator.prototype.constructor

The 初始值 of AsyncGenerator.prototype.constructor is the 内部对象 %AsyncGenerator%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.5.1.2AsyncGenerator.prototype.next ( `value` )

Let generator be the this value.
Let completion be NormalCompletion(value).
Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.3AsyncGenerator.prototype.return ( `value` )

Let generator be the this value.
Let completion be Completion{[[Type]]: return, [[Value]]: value, [[Target]]: empty}.
Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.4AsyncGenerator.prototype.throw ( `异常` )

Let generator be the this value.
Let completion be Completion{[[Type]]: throw, [[Value]]: 异常, [[Target]]: empty}.
Return ! AsyncGeneratorEnqueue(generator, completion).

25.5.1.5AsyncGenerator.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "AsyncGenerator".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.5.2异步生成器实例的属性

AsyncGenerator instances are initially created with the 内部属性 described below:

Table 68: 内部属性 of AsyncGenerator Instances

内部属性	Description
[[AsyncGeneratorState]]	The current execution state of the async generator. The possible values are: undefined, `"suspendedStart"`, `"suspendedYield"`, `"executing"`, `"awaiting-return"`, and `"completed"`.
[[AsyncGeneratorContext]]	The 执行上下文 that is used when executing the code of this async generator.
[[AsyncGeneratorQueue]]	A List of AsyncGeneratorRequest records which represent requests to resume the async generator.

25.5.3异步生成器抽象操作

25.5.3.1AsyncGeneratorRequest Records

The AsyncGeneratorRequest is a Record value used to store information about how an async generator should be resumed and contains capabilities for fulfilling or rejecting the corresponding promise.

They have the following fields:

Table 69: AsyncGeneratorRequest Record Fields

字段名	Value	Meaning
[[Completion]]	A Completion record	The completion which should be used to resume the async generator.
[[Capability]]	A PromiseCapability record	The promise capabilities associated with this request.

25.5.3.2AsyncGeneratorStart ( `generator`, `generatorBody` )

Assert: generator is an AsyncGenerator instance.
Assert: generator.[[AsyncGeneratorState]] is undefined.
Let genContext be the 运行时执行上下文.
Set the Generator component of genContext to generator.
Set the code 估值 state of genContext such that when 估值 is resumed for that 执行上下文 the following steps will be performed:
1. Let result be the result of evaluating generatorBody.
2. Assert: If we return here, the async generator either threw an 异常 or performed either an implicit or explicit return.
3. Remove genContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
4. Set generator.[[AsyncGeneratorState]] to "completed".
5. If result is a normal completion, let resultValue be undefined.
6. Else,
  1. Let resultValue be result.[[Value]].
  2. If result.[[Type]] is not return, then
    1. Return ! AsyncGeneratorReject(generator, resultValue).
7. Return ! AsyncGeneratorResolve(generator, resultValue, true).
Set generator.[[AsyncGeneratorContext]] to genContext.
Set generator.[[AsyncGeneratorState]] to "suspendedStart".
Set generator.[[AsyncGeneratorQueue]] to a new empty List.
Return undefined.

25.5.3.3AsyncGeneratorResolve ( `generator`, `value`, `done` )

Assert: generator is an AsyncGenerator instance.
Let queue be generator.[[AsyncGeneratorQueue]].
Assert: queue is not an empty List.
Remove the first element from queue and let next be the value of that element.
Let promiseCapability be next.[[Capability]].
Let iteratorResult be ! CreateIterResultObject(value, done).
Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
Perform ! AsyncGeneratorResumeNext(generator).
Return undefined.

25.5.3.4AsyncGeneratorReject ( `generator`, `异常` )

Assert: generator is an AsyncGenerator instance.
Let queue be generator.[[AsyncGeneratorQueue]].
Assert: queue is not an empty List.
Remove the first element from queue and let next be the value of that element.
Let promiseCapability be next.[[Capability]].
Perform ! Call(promiseCapability.[[Reject]], undefined, « 异常 »).
Perform ! AsyncGeneratorResumeNext(generator).
Return undefined.

25.5.3.5AsyncGeneratorResumeNext ( `generator` )

Assert: generator is an AsyncGenerator instance.
Let state be generator.[[AsyncGeneratorState]].
Assert: state is not "executing".
If state is "awaiting-return", return undefined.
Let queue be generator.[[AsyncGeneratorQueue]].
If queue is an empty List, return undefined.
Let next be the value of the first element of queue.
Assert: next is an AsyncGeneratorRequest record.
Let completion be next.[[Completion]].
If completion is an abrupt completion, then
1. If state is "suspendedStart", then
  1. Set generator.[[AsyncGeneratorState]] to "completed".
  2. Set state to "completed".
2. If state is "completed", then
  1. If completion.[[Type]] is return, then
    1. Set generator.[[AsyncGeneratorState]] to "awaiting-return".
    2. Let promiseCapability be ! NewPromiseCapability(%Promise%).
    3. Perform ! Call(promiseCapability.[[Resolve]], undefined, « completion.[[Value]] »).
    4. Let stepsFulfilled be the 算法步骤 defined in AsyncGeneratorResumeNext Return Processor Fulfilled Functions.
    5. Let onFulfilled be CreateBuiltinFunction(stepsFulfilled, « [[Generator]] »).
    6. Set onFulfilled.[[Generator]] to generator.
    7. Let stepsRejected be the 算法步骤 defined in AsyncGeneratorResumeNext Return Processor Rejected Functions.
    8. Let onRejected be CreateBuiltinFunction(stepsRejected, « [[Generator]] »).
    9. Set onRejected.[[Generator]] to generator.
    10. Let throwawayCapability be ! NewPromiseCapability(%Promise%).
    11. Set throwawayCapability.[[Promise]].[[PromiseIsHandled]] to true.
    12. Perform ! PerformPromiseThen(promiseCapability.[[Promise]], onFulfilled, onRejected, throwawayCapability).
    13. Return undefined.
  2. Else,
    1. Assert: completion.[[Type]] is throw.
    2. Perform ! AsyncGeneratorReject(generator, completion.[[Value]]).
    3. Return undefined.
Else if state is "completed", return ! AsyncGeneratorResolve(generator, undefined, true).
Assert: state is either "suspendedStart" or "suspendedYield".
Let genContext be generator.[[AsyncGeneratorContext]].
Let callerContext be the 运行时执行上下文.
Suspend callerContext.
Set generator.[[AsyncGeneratorState]] to "executing".
Push genContext onto the 执行上下文堆栈; genContext is now the 运行时执行上下文.
Resume the suspended 估值 of genContext using completion as the result of the operation that suspended it. Let result be the 完成记录 returned by the resumed computation.
Assert: result is never an abrupt completion.
Assert: When we return here, genContext has already been removed from the 执行上下文堆栈 and callerContext is the currently 运行时执行上下文.
Return undefined.

25.5.3.5.1AsyncGeneratorResumeNext Return Processor Fulfilled Functions

An AsyncGeneratorResumeNext return processor fulfilled function is an anonymous 内置函数 that is used as part of the AsyncGeneratorResumeNext specification device to unwrap promises passed in to the AsyncGenerator.prototype.return ( value ) method. Each AsyncGeneratorResumeNext return processor fulfilled function has a [[Generator]] 内部属性.

When an AsyncGeneratorResumeNext return processor fulfilled function F is called with argument value, 执行如下:

Set F.[[Generator]].[[AsyncGeneratorState]] to "completed".
Return ! AsyncGeneratorResolve(F.[[Generator]], value, true).

The length property of an AsyncGeneratorResumeNext return processor fulfilled function is 1.

25.5.3.5.2AsyncGeneratorResumeNext Return Processor Rejected Functions

An AsyncGeneratorResumeNext return processor rejected function is an anonymous 内置函数 that is used as part of the AsyncGeneratorResumeNext specification device to unwrap promises passed in to the AsyncGenerator.prototype.return ( value ) method. Each AsyncGeneratorResumeNext return processor rejected function has a [[Generator]] 内部属性.

When an AsyncGeneratorResumeNext return processor rejected function F is called with argument reason, 执行如下:

Set F.[[Generator]].[[AsyncGeneratorState]] to "completed".
Return ! AsyncGeneratorReject(F.[[Generator]], reason).

The length property of an AsyncGeneratorResumeNext return processor rejected function is 1.

25.5.3.6AsyncGeneratorEnqueue ( `generator`, `completion` )

Assert: completion is a 完成记录.
Let promiseCapability be ! NewPromiseCapability(%Promise%).
If Type(generator) is not Object, or if generator does not have an [[AsyncGeneratorState]] 内部属性, then
1. Let badGeneratorError be a newly created TypeError object.
2. Perform ! Call(promiseCapability.[[Reject]], undefined, « badGeneratorError »).
3. Return promiseCapability.[[Promise]].
Let queue be generator.[[AsyncGeneratorQueue]].
Let request be AsyncGeneratorRequest{[[Completion]]: completion, [[Capability]]: promiseCapability}.
Append request to the end of queue.
Let state be generator.[[AsyncGeneratorState]].
If state is not "executing", then
1. Perform ! AsyncGeneratorResumeNext(generator).
Return promiseCapability.[[Promise]].

25.5.3.7AsyncGeneratorYield ( `value` )

The 抽象操作 AsyncGeneratorYield with argument value 执行如下:

Let genContext be the 运行时执行上下文.
Assert: genContext is the 执行上下文 of a generator.
Let generator be the value of the Generator component of genContext.
Assert: GetGeneratorKind() is async.
Set value to ? Await(value).
Set generator.[[AsyncGeneratorState]] to "suspendedYield".
Remove genContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
Set the code 估值 state of genContext such that when 估值 is resumed with a Completion resumptionValue the following steps will be performed:
1. If resumptionValue.[[Type]] is not return, return Completion(resumptionValue).
2. Let awaited be Await(resumptionValue.[[Value]]).
3. If awaited.[[Type]] is throw, return Completion(awaited).
4. Assert: awaited.[[Type]] is normal.
5. Return Completion{[[Type]]: return, [[Value]]: awaited.[[Value]], [[Target]]: empty}.
6. NOTE: When one of the above steps returns, it returns to the 估值 of the YieldExpression production that originally called this 抽象操作.
Return ! AsyncGeneratorResolve(generator, value, false).
NOTE: This returns to the 估值 of the operation that had most previously resumed 估值 of genContext.

25.6Promise 对象

A Promise is an object that is used as a placeholder for the eventual results of a deferred (and possibly asynchronous) computation.

Any promise 对象 is in one of three mutually exclusive states: fulfilled, rejected, and pending:

A promise p is fulfilled if p.then(f, r) will immediately enqueue a Job to call the function f.
A promise p is rejected if p.then(f, r) will immediately enqueue a Job to call the function r.
A promise is pending if it is neither fulfilled nor rejected.

A promise is said to be settled if it is not pending, i.e. if it is either fulfilled or rejected.

A promise is resolved if it is settled or if it has been “locked in” to match the state of another promise. Attempting to resolve or reject a resolved promise has no effect. A promise is unresolved if it is not resolved. An unresolved promise is always in the pending state. A resolved promise may be pending, fulfilled or rejected.

25.6.1Promise 抽象操作

25.6.1.1PromiseCapability Records

A PromiseCapability is a Record value used to encapsulate a promise 对象 along with the functions that are capable of resolving or rejecting that promise 对象. PromiseCapability Records are produced by the NewPromiseCapability 抽象操作.

PromiseCapability Records have the fields listed in Table 70.

Table 70: PromiseCapability Record Fields

字段名	Value	Meaning
[[Promise]]	An object	An object that is usable as a promise.
[[Resolve]]	A 函数对象	The function that is used to resolve the given promise 对象.
[[Reject]]	A 函数对象	The function that is used to reject the given promise 对象.

25.6.1.1.1IfAbruptRejectPromise ( `value`, `capability` )

IfAbruptRejectPromise is a shorthand for a sequence of 算法步骤 that use a PromiseCapability Record. An 算法步骤 of the form:

IfAbruptRejectPromise(value, capability).

等同于:

If value is an abrupt completion, then
1. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »).
2. Return capability.[[Promise]].
Else if value is a 完成记录, let value be value.[[Value]].

25.6.1.2PromiseReaction Records

The PromiseReaction is a Record value used to store information about how a promise should react when it becomes resolved or rejected with a given value. PromiseReaction records are created by the PerformPromiseThen 抽象操作, and are used by a PromiseReactionJob.

PromiseReaction records have the fields listed in Table 71.

Table 71: PromiseReaction Record Fields

字段名	Value	Meaning
[[Capability]]	A PromiseCapability Record	The capabilities of the promise for which this record provides a reaction handler.
[[Type]]	Either `"Fulfill"` or `"Reject"`.	The [[Type]] is used when [[Handler]] is undefined to allow for behaviour specific to the settlement type.
[[Handler]]	A 函数对象 or undefined.	The function that should be applied to the incoming value, and whose 返回值 will govern what happens to the derived promise. If [[Handler]] is undefined, a function that depends on the value of [[Type]] will be used instead.

25.6.1.3CreateResolvingFunctions ( `promise` )

When CreateResolvingFunctions is performed with argument promise, 执行如下:

Let alreadyResolved be a new Record { [[Value]]: false }.
Let stepsResolve be the 算法步骤 defined in Promise Resolve Functions (25.6.1.3.2).
Let resolve be CreateBuiltinFunction(stepsResolve, « [[Promise]], [[AlreadyResolved]] »).
Set resolve.[[Promise]] to promise.
Set resolve.[[AlreadyResolved]] to alreadyResolved.
Let stepsReject be the 算法步骤 defined in Promise Reject Functions (25.6.1.3.1).
Let reject be CreateBuiltinFunction(stepsReject, « [[Promise]], [[AlreadyResolved]] »).
Set reject.[[Promise]] to promise.
Set reject.[[AlreadyResolved]] to alreadyResolved.
Return a new Record { [[Resolve]]: resolve, [[Reject]]: reject }.

25.6.1.3.1Promise Reject Functions

A promise reject function is an anonymous 内置函数 that has [[Promise]] and [[AlreadyResolved]] 内部属性.

When a promise reject function F is called with argument reason, 执行如下:

Assert: F has a [[Promise]] 内部属性 whose value is an Object.
Let promise be F.[[Promise]].
Let alreadyResolved be F.[[AlreadyResolved]].
If alreadyResolved.[[Value]] is true, return undefined.
Set alreadyResolved.[[Value]] to true.
Return RejectPromise(promise, reason).

The length property of a promise reject function is 1.

25.6.1.3.2Promise Resolve Functions

A promise resolve function is an anonymous 内置函数 that has [[Promise]] and [[AlreadyResolved]] 内部属性.

When a promise resolve function F is called with argument resolution, 执行如下:

Assert: F has a [[Promise]] 内部属性 whose value is an Object.
Let promise be F.[[Promise]].
Let alreadyResolved be F.[[AlreadyResolved]].
If alreadyResolved.[[Value]] is true, return undefined.
Set alreadyResolved.[[Value]] to true.
If SameValue(resolution, promise) is true, then
1. Let selfResolutionError be a newly created TypeError object.
2. Return RejectPromise(promise, selfResolutionError).
If Type(resolution) is not Object, then
1. Return FulfillPromise(promise, resolution).
Let then be Get(resolution, "then").
If then is an abrupt completion, then
1. Return RejectPromise(promise, then.[[Value]]).
Let thenAction be then.[[Value]].
If IsCallable(thenAction) is false, then
1. Return FulfillPromise(promise, resolution).
Perform EnqueueJob("PromiseJobs", PromiseResolveThenableJob, « promise, resolution, thenAction »).
Return undefined.

The length property of a promise resolve function is 1.

25.6.1.4FulfillPromise ( `promise`, `value` )

When the FulfillPromise 抽象操作 is called with arguments promise and value, 执行如下:

Assert: The value of promise.[[PromiseState]] is "pending".
Let reactions be promise.[[PromiseFulfillReactions]].
Set promise.[[PromiseResult]] to value.
Set promise.[[PromiseFulfillReactions]] to undefined.
Set promise.[[PromiseRejectReactions]] to undefined.
Set promise.[[PromiseState]] to "fulfilled".
Return TriggerPromiseReactions(reactions, value).

25.6.1.5NewPromiseCapability ( `C` )

The 抽象操作 NewPromiseCapability takes a 构造器 function, and attempts to use that 构造器 function in the fashion of the 内置 Promise 构造器 to create a promise 对象 and extract its resolve and reject functions. The promise plus the resolve and reject functions are used to initialize a new PromiseCapability Record which is returned as the value of this 抽象操作.

If IsConstructor(C) is false, 抛出一个 TypeError 异常.
NOTE: C is assumed to be a 构造器 function that supports the parameter conventions of the Promise 构造器 (see 25.6.3.1).
Let promiseCapability be a new PromiseCapability { [[Promise]]: undefined, [[Resolve]]: undefined, [[Reject]]: undefined }.
Let steps be the 算法步骤 defined in GetCapabilitiesExecutor Functions.
Let executor be CreateBuiltinFunction(steps, « [[Capability]] »).
Set executor.[[Capability]] to promiseCapability.
Let promise be ? Construct(C, « executor »).
If IsCallable(promiseCapability.[[Resolve]]) is false, 抛出一个 TypeError 异常.
If IsCallable(promiseCapability.[[Reject]]) is false, 抛出一个 TypeError 异常.
Set promiseCapability.[[Promise]] to promise.
Return promiseCapability.

Note

This 抽象操作 supports Promise subclassing, as it is generic on any 构造器 that calls a passed executor function argument in the same way as the Promise 构造器. It is used to generalize static methods of the Promise 构造器 to any subclass.

25.6.1.5.1GetCapabilitiesExecutor Functions

A GetCapabilitiesExecutor function is an anonymous 内置函数 that has a [[Capability]] 内部属性.

When a GetCapabilitiesExecutor function F is called with arguments resolve and reject, 执行如下:

Assert: F has a [[Capability]] 内部属性 whose value is a PromiseCapability Record.
Let promiseCapability be F.[[Capability]].
If promiseCapability.[[Resolve]] is not undefined, 抛出一个 TypeError 异常.
If promiseCapability.[[Reject]] is not undefined, 抛出一个 TypeError 异常.
Set promiseCapability.[[Resolve]] to resolve.
Set promiseCapability.[[Reject]] to reject.
Return undefined.

The length property of a GetCapabilitiesExecutor function is 2.

25.6.1.6IsPromise ( `x` )

The 抽象操作 IsPromise checks for the promise brand on an object.

If Type(x) is not Object, return false.
If x does not have a [[PromiseState]] 内部属性, return false.
Return true.

25.6.1.7RejectPromise ( `promise`, `reason` )

When the RejectPromise 抽象操作 is called with arguments promise and reason, 执行如下:

Assert: The value of promise.[[PromiseState]] is "pending".
Let reactions be promise.[[PromiseRejectReactions]].
Set promise.[[PromiseResult]] to reason.
Set promise.[[PromiseFulfillReactions]] to undefined.
Set promise.[[PromiseRejectReactions]] to undefined.
Set promise.[[PromiseState]] to "rejected".
If promise.[[PromiseIsHandled]] is false, perform HostPromiseRejectionTracker(promise, "reject").
Return TriggerPromiseReactions(reactions, reason).

25.6.1.8TriggerPromiseReactions ( `reactions`, `argument` )

The 抽象操作 TriggerPromiseReactions takes a collection of PromiseReactionRecords and enqueues a new Job for each record. Each such Job processes the [[Type]] and [[Handler]] of the PromiseReactionRecord, and if the [[Handler]] is a function, calls it passing the given argument. If the [[Handler]] is undefined, the behaviour is determined by the [[Type]].

For each reaction in reactions, in original insertion order, do
1. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « reaction, argument »).
Return undefined.

25.6.1.9HostPromiseRejectionTracker ( `promise`, `operation` )

HostPromiseRejectionTracker is an 实现-defined 抽象操作 that allows 宿主环境 to track promise rejections.

An 实现 of HostPromiseRejectionTracker must complete normally in all cases. The default 实现 of HostPromiseRejectionTracker is to unconditionally return an empty normal completion.

Note 1

HostPromiseRejectionTracker is called in two scenarios:

When a promise is rejected without any handlers, it is called with its operation argument set to "reject".
When a handler is added to a rejected promise for the first time, it is called with its operation argument set to "handle".

A typical 实现 of HostPromiseRejectionTracker might try to notify developers of unhandled rejections, while also being careful to notify them if such previous notifications are later invalidated by new handlers being attached.

Note 2

If operation is "handle", an 实现 should not hold a reference to promise in a way that would interfere with garbage collection. An 实现 may hold a reference to promise if operation is "reject", since it is expected that rejections will be rare and not on hot code paths.

25.6.2Promise 作业

25.6.2.1PromiseReactionJob ( `reaction`, `argument` )

The job PromiseReactionJob with parameters reaction and argument applies the appropriate handler to the incoming value, and uses the handler's 返回值 to resolve or reject the derived promise associated with that handler.

Assert: reaction is a PromiseReaction Record.
Let promiseCapability be reaction.[[Capability]].
Let type be reaction.[[Type]].
Let handler be reaction.[[Handler]].
If handler is undefined, then
1. If type is "Fulfill", let handlerResult be NormalCompletion(argument).
2. Else,
  1. Assert: type is "Reject".
  2. Let handlerResult be Completion {[[Type]]: throw, [[Value]]: argument, [[Target]]: empty}.
Else, let handlerResult be Call(handler, undefined, « argument »).
If handlerResult is an abrupt completion, then
1. Let status be Call(promiseCapability.[[Reject]], undefined, « handlerResult.[[Value]] »).
Else,
1. Let status be Call(promiseCapability.[[Resolve]], undefined, « handlerResult.[[Value]] »).
Return Completion(status).

25.6.2.2PromiseResolveThenableJob ( `promiseToResolve`, `thenable`, `then` )

The job PromiseResolveThenableJob with parameters promiseToResolve, thenable, and then 执行如下:

Let resolvingFunctions be CreateResolvingFunctions(promiseToResolve).
Let thenCallResult be Call(then, thenable, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
If thenCallResult is an abrupt completion, then
1. Let status be Call(resolvingFunctions.[[Reject]], undefined, « thenCallResult.[[Value]] »).
2. Return Completion(status).
Return Completion(thenCallResult).

Note

This Job uses the supplied thenable and its then method to resolve the given promise. This process must take place as a Job to ensure that the 估值 of the then method occurs after 估值 of any surrounding code has completed.

25.6.3Promise 构造器

The Promise 构造器 is the %Promise% 内部对象 and the 初始值 of the Promise property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 promise 对象. Promise is not intended to be called as a function and will 抛出一个异常 when called in that manner.

The Promise 构造器被设计成可被子类化的. 它可以用作 the value in an extends clause of a class definition. 子类构造器 that 旨在继承特定的 Promise behaviour must include a super call to the Promise 构造器以便创建和初始化子类实例 with the 内部状态 necessary to support the Promise and Promise.prototype 内置方法.

25.6.3.1Promise ( `executor` )

When the Promise function is called with argument executor, 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
If IsCallable(executor) is false, 抛出一个 TypeError 异常.
Let promise be ? OrdinaryCreateFromConstructor(NewTarget, "%PromisePrototype%", « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »).
Set promise.[[PromiseState]] to "pending".
Set promise.[[PromiseFulfillReactions]] to a new empty List.
Set promise.[[PromiseRejectReactions]] to a new empty List.
Set promise.[[PromiseIsHandled]] to false.
Let resolvingFunctions be CreateResolvingFunctions(promise).
Let completion be Call(executor, undefined, « resolvingFunctions.[[Resolve]], resolvingFunctions.[[Reject]] »).
If completion is an abrupt completion, then
1. Perform ? Call(resolvingFunctions.[[Reject]], undefined, « completion.[[Value]] »).
Return promise.

Note

The executor argument must be a 函数对象. It is called for initiating and reporting completion of the possibly deferred action represented by this promise 对象. The executor is called with two arguments: resolve and reject. These are functions that may be used by the executor function to report eventual completion or failure of the deferred computation. Returning from the executor function does not mean that the deferred action has been completed but only that the request to eventually perform the deferred action has been accepted.

The resolve function that is passed to an executor function accepts a single argument. The executor code may eventually call the resolve function to indicate that it wishes to resolve the associated promise 对象. The argument passed to the resolve function represents the eventual value of the deferred action and can be either the actual fulfillment value or another promise 对象 which will provide the value if it is fulfilled.

The reject function that is passed to an executor function accepts a single argument. The executor code may eventually call the reject function to indicate that the associated Promise is rejected and will never be fulfilled. The argument passed to the reject function is used as the rejection value of the promise. Typically it will be an Error object.

The resolve and reject functions passed to an executor function by the Promise 构造器 have the capability to actually resolve and reject the associated promise. Subclasses may have different 构造器 behaviour that passes in customized values for resolve and reject.

25.6.4Promise 构造器的属性

[[Prototype]] 内部属性的值 of the Promise 构造器 is the 内部对象 %FunctionPrototype%.

The Promise 构造器有以下属性:

25.6.4.1Promise.all ( `iterable` )

The all function returns a new promise which is fulfilled with an array of fulfillment values for the passed promises, or rejects with the reason of the first passed promise that rejects. It resolves all elements of the passed iterable to promises as it runs this 算法.

Let C be the this value.
If Type(C) is not Object, 抛出一个 TypeError 异常.
Let promiseCapability be ? NewPromiseCapability(C).
Let iteratorRecord be GetIterator(iterable).
IfAbruptRejectPromise(iteratorRecord, promiseCapability).
Let result be PerformPromiseAll(iteratorRecord, C, promiseCapability).
If result is an abrupt completion, then
1. If iteratorRecord.[[Done]] is false, let result be IteratorClose(iteratorRecord, result).
2. IfAbruptRejectPromise(result, promiseCapability).
Return Completion(result).

This function is the %Promise_all% 内部对象.

Note

The all function requires its this value to be a 构造器 function that supports the parameter conventions of the Promise 构造器.

25.6.4.1.1运行时语义: PerformPromiseAll( `iteratorRecord`, `构造器`, `resultCapability` )

When the PerformPromiseAll 抽象操作 is called with arguments iteratorRecord, 构造器, and resultCapability, 执行如下:

Assert: 构造器 is a 构造器 function.
Assert: resultCapability is a PromiseCapability Record.
Let values be a new empty List.
Let remainingElementsCount be a new Record { [[Value]]: 1 }.
Let index be 0.
Repeat,
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, then
  1. Set iteratorRecord.[[Done]] to true.
  2. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
  3. If remainingElementsCount.[[Value]] is 0, then
    1. Let valuesArray be CreateArrayFromList(values).
    2. Perform ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »).
  4. Return resultCapability.[[Promise]].
5. Let nextValue be IteratorValue(next).
6. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
7. ReturnIfAbrupt(nextValue).
8. Append undefined to values.
9. Let nextPromise be ? Invoke(构造器, "resolve", « nextValue »).
10. Let steps be the 算法步骤 defined in Promise.all Resolve Element Functions.
11. Let resolveElement be CreateBuiltinFunction(steps, « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »).
12. Set resolveElement.[[AlreadyCalled]] to a new Record { [[Value]]: false }.
13. Set resolveElement.[[Index]] to index.
14. Set resolveElement.[[Values]] to values.
15. Set resolveElement.[[Capability]] to resultCapability.
16. Set resolveElement.[[RemainingElements]] to remainingElementsCount.
17. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.
18. Perform ? Invoke(nextPromise, "then", « resolveElement, resultCapability.[[Reject]] »).
19. Set index to index + 1.

25.6.4.1.2`Promise.all` Resolve Element Functions

A Promise.all resolve element function is an anonymous 内置函数 that is used to resolve a specific Promise.all element. Each Promise.all resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] 内部属性.

When a Promise.all resolve element function F is called with argument x, 执行如下:

Let alreadyCalled be F.[[AlreadyCalled]].
If alreadyCalled.[[Value]] is true, return undefined.
Set alreadyCalled.[[Value]] to true.
Let index be F.[[Index]].
Let values be F.[[Values]].
Let promiseCapability be F.[[Capability]].
Let remainingElementsCount be F.[[RemainingElements]].
Set values[index] to x.
Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
If remainingElementsCount.[[Value]] is 0, then
1. Let valuesArray be CreateArrayFromList(values).
2. Return ? Call(promiseCapability.[[Resolve]], undefined, « valuesArray »).
Return undefined.

The length property of a Promise.all resolve element function is 1.

25.6.4.2Promise.prototype

The 初始值 of Promise.prototype is the 内部对象 %PromisePrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.6.4.3Promise.race ( `iterable` )

The race function returns a new promise which is settled in the same way as the first passed promise to settle. It resolves all elements of the passed iterable to promises as it runs this 算法.

Let C be the this value.
If Type(C) is not Object, 抛出一个 TypeError 异常.
Let promiseCapability be ? NewPromiseCapability(C).
Let iteratorRecord be GetIterator(iterable).
IfAbruptRejectPromise(iteratorRecord, promiseCapability).
Let result be PerformPromiseRace(iteratorRecord, C, promiseCapability).
If result is an abrupt completion, then
1. If iteratorRecord.[[Done]] is false, let result be IteratorClose(迭代器, result).
2. IfAbruptRejectPromise(result, promiseCapability).
Return Completion(result).

Note 1

If the iterable argument is empty or if none of the promises in iterable ever settle then the pending promise returned by this method will never be settled.

Note 2

The race function expects its this value to be a 构造器 function that supports the parameter conventions of the Promise 构造器. It also expects that its this value provides a resolve method.

25.6.4.3.1运行时语义: PerformPromiseRace ( `iteratorRecord`, `构造器`, `resultCapability` )

When the PerformPromiseRace 抽象操作 is called with arguments iteratorRecord, 构造器, and resultCapability, 执行如下:

Assert: 构造器 is a 构造器 function.
Assert: resultCapability is a PromiseCapability Record.
Repeat,
1. Let next be IteratorStep(iteratorRecord).
2. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
3. ReturnIfAbrupt(next).
4. If next is false, then
  1. Set iteratorRecord.[[Done]] to true.
  2. Return resultCapability.[[Promise]].
5. Let nextValue be IteratorValue(next).
6. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
7. ReturnIfAbrupt(nextValue).
8. Let nextPromise be ? Invoke(构造器, "resolve", « nextValue »).
9. Perform ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], resultCapability.[[Reject]] »).

25.6.4.4Promise.reject ( `r` )

The reject function returns a new promise rejected with the passed argument.

Let C be the this value.
If Type(C) is not Object, 抛出一个 TypeError 异常.
Let promiseCapability be ? NewPromiseCapability(C).
Perform ? Call(promiseCapability.[[Reject]], undefined, « r »).
Return promiseCapability.[[Promise]].

This function is the %Promise_reject% 内部对象.

Note

The reject function expects its this value to be a 构造器 function that supports the parameter conventions of the Promise 构造器.

25.6.4.5Promise.resolve ( `x` )

The resolve function returns either a new promise resolved with the passed argument, or the argument itself if the argument is a promise produced by this 构造器.

Let C be the this value.
If Type(C) is not Object, 抛出一个 TypeError 异常.
Return ? PromiseResolve(C, x).

This function is the %Promise_resolve% 内部对象.

Note

The resolve function expects its this value to be a 构造器 function that supports the parameter conventions of the Promise 构造器.

25.6.4.5.1PromiseResolve ( `C`, `x` )

The 抽象操作 PromiseResolve, given a 构造器 and a value, returns a new promise resolved with that value.

Assert: Type(C) is Object.
If IsPromise(x) is true, then
1. Let xConstructor be ? Get(x, "构造器").
2. If SameValue(xConstructor, C) is true, return x.
Let promiseCapability be ? NewPromiseCapability(C).
Perform ? Call(promiseCapability.[[Resolve]], undefined, « x »).
Return promiseCapability.[[Promise]].

25.6.4.6get Promise [ @@species ]

Promise[@@species] is an 访问器属性 whose set 访问器函数 is undefined. Its get 访问器函数执行如下:

Return the this value.

The value of the name property of this function is "get [Symbol.species]".

Note

Promise prototype methods normally use their this object's 构造器 to create a derived object. However, a subclass 构造器 may over-ride that default behaviour by redefining its @@species property.

25.6.5Promise 原型对象的属性

The Promise 原型对象 is the 内部对象 %PromisePrototype%. [[Prototype]] 内部属性的值 of the Promise 原型对象 is the 内部对象 %ObjectPrototype%. The Promise 原型对象 is an 普通对象. It does not have a [[PromiseState]] 内部属性 or any of the other 内部属性 of Promise 实例.

25.6.5.1Promise.prototype.catch ( `onRejected` )

When the catch method is called with argument onRejected, 执行如下:

Let promise be the this value.
Return ? Invoke(promise, "then", « undefined, onRejected »).

25.6.5.2Promise.prototype.constructor

The 初始值 of Promise.prototype.constructor is the 内部对象 %Promise%.

25.6.5.3Promise.prototype.finally ( `onFinally` )

When the finally method is called with argument onFinally, 执行如下:

Let promise be the this value.
If Type(promise) is not Object, 抛出一个 TypeError 异常.
Let C be ? SpeciesConstructor(promise, %Promise%).
Assert: IsConstructor(C) is true.
If IsCallable(onFinally) is false, then
1. Let thenFinally be onFinally.
2. Let catchFinally be onFinally.
Else,
1. Let stepsThenFinally be the 算法步骤 defined in Then Finally Functions.
2. Let thenFinally be CreateBuiltinFunction(stepsThenFinally, « [[构造器]], [[OnFinally]] »).
3. Set thenFinally.[[构造器]] to C.
4. Set thenFinally.[[OnFinally]] to onFinally.
5. Let stepsCatchFinally be the 算法步骤 defined in Catch Finally Functions.
6. Let catchFinally be CreateBuiltinFunction(stepsCatchFinally, « [[构造器]], [[OnFinally]] »).
7. Set catchFinally.[[构造器]] to C.
8. Set catchFinally.[[OnFinally]] to onFinally.
Return ? Invoke(promise, "then", « thenFinally, catchFinally »).

25.6.5.3.1Then Finally Functions

A Then Finally function is an anonymous 内置函数 that has a [[构造器]] and an [[OnFinally]] 内部属性. The value of the [[构造器]] 内部属性 is a Promise-like 构造器函数对象, and the value of the [[OnFinally]] 内部属性 is a 函数对象.

When a Then Finally function F is called with argument value, 执行如下:

Let onFinally be F.[[OnFinally]].
Assert: IsCallable(onFinally) is true.
Let result be ? Call(onFinally, undefined).
Let C be F.[[构造器]].
Assert: IsConstructor(C) is true.
Let promise be ? PromiseResolve(C, result).
Let valueThunk be equivalent to a function that returns value.
Return ? Invoke(promise, "then", « valueThunk »).

The length property of a Then Finally function is 1.

25.6.5.3.2Catch Finally Functions

A Catch Finally function is an anonymous 内置函数 that has a [[构造器]] and an [[OnFinally]] 内部属性. The value of the [[构造器]] 内部属性 is a Promise-like 构造器函数对象, and the value of the [[OnFinally]] 内部属性 is a 函数对象.

When a Catch Finally function F is called with argument reason, 执行如下:

Let onFinally be F.[[OnFinally]].
Assert: IsCallable(onFinally) is true.
Let result be ? Call(onFinally, undefined).
Let C be F.[[构造器]].
Assert: IsConstructor(C) is true.
Let promise be ? PromiseResolve(C, result).
Let thrower be equivalent to a function that throws reason.
Return ? Invoke(promise, "then", « thrower »).

The length property of a Catch Finally function is 1.

25.6.5.4Promise.prototype.then ( `onFulfilled`, `onRejected` )

When the then method is called with arguments onFulfilled and onRejected, 执行如下:

Let promise be the this value.
If IsPromise(promise) is false, 抛出一个 TypeError 异常.
Let C be ? SpeciesConstructor(promise, %Promise%).
Let resultCapability be ? NewPromiseCapability(C).
Return PerformPromiseThen(promise, onFulfilled, onRejected, resultCapability).

This function is the %PromiseProto_then% 内部对象.

25.6.5.4.1PerformPromiseThen ( `promise`, `onFulfilled`, `onRejected`, `resultCapability` )

The 抽象操作 PerformPromiseThen performs the “then” operation on promise using onFulfilled and onRejected as its settlement actions. The result is resultCapability's promise.

Assert: IsPromise(promise) is true.
Assert: resultCapability is a PromiseCapability Record.
If IsCallable(onFulfilled) is false, then
1. Set onFulfilled to undefined.
If IsCallable(onRejected) is false, then
1. Set onRejected to undefined.
Let fulfillReaction be the PromiseReaction { [[Capability]]: resultCapability, [[Type]]: "Fulfill", [[Handler]]: onFulfilled }.
Let rejectReaction be the PromiseReaction { [[Capability]]: resultCapability, [[Type]]: "Reject", [[Handler]]: onRejected }.
If promise.[[PromiseState]] is "pending", then
1. Append fulfillReaction as the last element of the List that is promise.[[PromiseFulfillReactions]].
2. Append rejectReaction as the last element of the List that is promise.[[PromiseRejectReactions]].
Else if promise.[[PromiseState]] is "fulfilled", then
1. Let value be promise.[[PromiseResult]].
2. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « fulfillReaction, value »).
Else,
1. Assert: The value of promise.[[PromiseState]] is "rejected".
2. Let reason be promise.[[PromiseResult]].
3. If promise.[[PromiseIsHandled]] is false, perform HostPromiseRejectionTracker(promise, "handle").
4. Perform EnqueueJob("PromiseJobs", PromiseReactionJob, « rejectReaction, reason »).
Set promise.[[PromiseIsHandled]] to true.
Return resultCapability.[[Promise]].

25.6.5.5Promise.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "Promise".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.6.6Promise 实例的属性

Promise 实例 are 普通对象 that 继承属性 from the Promise 原型对象 (the intrinsic, %PromisePrototype%). Promise 实例 are initially created with the 内部属性 described in Table 72.

Table 72: 内部属性 of Promise 实例

内部属性	Description
[[PromiseState]]	A String 值 that governs how a promise will react to incoming calls to its `then` method. The possible values are: `"pending"`, `"fulfilled"`, and `"rejected"`.
[[PromiseResult]]	The value with which the promise has been fulfilled or rejected, if any. Only meaningful if [[PromiseState]] is not `"pending"`.
[[PromiseFulfillReactions]]	A List of PromiseReaction records to be processed when/if the promise transitions from the `"pending"` state to the `"fulfilled"` state.
[[PromiseRejectReactions]]	A List of PromiseReaction records to be processed when/if the promise transitions from the `"pending"` state to the `"rejected"` state.
[[PromiseIsHandled]]	A boolean indicating whether the promise has ever had a fulfillment or rejection handler; used in unhandled rejection tracking.

25.7异步函数对象

异步函数对象 are functions that are usually created by evaluating AsyncFunctionDeclarations, AsyncFunctionExpressions, AsyncMethods, and AsyncArrowFunctions. They may also be created by calling the %AsyncFunction% intrinsic.

25.7.1异步函数构造器

The AsyncFunction 构造器 is the %AsyncFunction% 内部对象 and is a subclass of Function. When AsyncFunction 被作为一个函数调用而不是一个构造器, 它会创建和初始化一个新的 AsyncFunction object. Thus the function call AsyncFunction(…) is equivalent to the object creation expression new AsyncFunction(…) with the same arguments.

The AsyncFunction 构造器被设计成可被子类化的. 它可以用作 the value of an extends clause of a class definition. 子类构造器 that 旨在继承特定的 AsyncFunction behaviour must include a super call to the AsyncFunction 构造器 to create and initialize a subclass instance with the 内部属性 necessary for 内置 async function behaviour.

25.7.1.1AsyncFunction( `p1`, `p2`, … , `pn`, `body` )

The last argument specifies the body (executable code) of an async function. Any preceding arguments specify formal parameters.

When the AsyncFunction function is called with some arguments p1, p2, …, pn, body (where n might be 0, that is, there are no p arguments, and where body might also not be provided), 执行如下:

Let C be the active 函数对象.
Let args be the argumentsList that was passed to this function by [[Call]] or [[Construct]].
Return CreateDynamicFunction(C, NewTarget, "async", args).

Note

See NOTE for 19.2.1.1.

25.7.2异步函数构造器的属性

The AsyncFunction 构造器 is a 标准内置函数对象 that inherits from the Function 构造器. [[Prototype]] 内部属性的值 of the AsyncFunction 构造器 is the 内部对象 %Function%.

The value of the [[Extensible]] 内部属性 of the AsyncFunction 构造器 is true.

The value of the name property of the AsyncFunction is "AsyncFunction".

The AsyncFunction 构造器有以下属性:

25.7.2.1AsyncFunction.length

This is a 数据属性 with a value of 1. 该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.2.2AsyncFunction.prototype

The 初始值 of AsyncFunction.prototype is the 内部对象 %AsyncFunctionPrototype%.

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

25.7.3异步函数原型对象的属性

The AsyncFunction 原型对象 is an 普通对象. It is not a 函数对象 and does not have an [[ECMAScriptCode]] 内部属性 or any other of the 内部属性 listed in Table 27. In addition to being the value of the prototype property of the %AsyncFunction% intrinsic, it is the %AsyncFunctionPrototype% intrinsic.

[[Prototype]] 内部属性的值 of the AsyncFunction 原型对象 is the %FunctionPrototype% 内部对象. The 初始值 of the [[Extensible]] 内部属性 of the AsyncFunction 原型对象 is true.

25.7.3.1AsyncFunction.prototype.constructor

The 初始值 of AsyncFunction.prototype.constructor is the 内部对象 %AsyncFunction%

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.3.2AsyncFunction.prototype [ @@toStringTag ]

The 初始值 of the @@toStringTag property is the String 值 "AsyncFunction".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.

25.7.4异步函数实例

Every AsyncFunction instance is an ES 函数对象 and has the 内部属性 listed in Table 27. The value of the [[FunctionKind]] 内部属性 for all such instances is "async". 异步函数实例 are not constructors and do not have a [[Construct]] 内部方法. 异步函数实例 do not have a prototype property as they are not constructable.

Each AsyncFunction instance 拥有以下自身属性:

25.7.4.1length

The specification for the length property of 函数实例 given in 19.2.4.1 also applies to 异步函数实例.

25.7.4.2name

The specification for the name property of 函数实例 given in 19.2.4.2 also applies to 异步函数实例.

25.7.5异步函数抽象操作

25.7.5.1AsyncFunctionCreate ( `kind`, `parameters`, `body`, `Scope`, `Strict` )

The 抽象操作 AsyncFunctionCreate requires the arguments: kind which is one of (Normal, Method, Arrow), a parameter list 解析节点 specified by parameters, a body 解析节点 specified by body, a 词法环境 specified by Scope, and a Boolean flag Strict. AsyncFunctionCreate 执行如下:

Let functionPrototype be the 内部对象 %AsyncFunctionPrototype%.
Let F be ! FunctionAllocate(functionPrototype, Strict, "async").
Return ! FunctionInitialize(F, kind, parameters, body, Scope).

25.7.5.2AsyncFunctionStart ( `promiseCapability`, `asyncFunctionBody` )

Let runningContext be the 运行时执行上下文.
Let asyncContext be a copy of runningContext.
Set the code 估值 state of asyncContext such that when 估值 is resumed for that 执行上下文 the following steps will be performed:
1. Let result be the result of evaluating asyncFunctionBody.
2. Assert: If we return here, the async function either threw an 异常 or performed an implicit or explicit return; all awaiting is done.
3. Remove asyncContext from the 执行上下文堆栈 and restore the 执行上下文 that is at the top of the 执行上下文堆栈 as the 运行时执行上下文.
4. If result.[[Type]] is normal, then
  1. Perform ! Call(promiseCapability.[[Resolve]], undefined, «undefined»).
5. Else if result.[[Type]] is return, then
  1. Perform ! Call(promiseCapability.[[Resolve]], undefined, «result.[[Value]]»).
6. Else,
  1. Assert: result.[[Type]] is throw.
  2. Perform ! Call(promiseCapability.[[Reject]], undefined, «result.[[Value]]»).
7. Return.
Push asyncContext onto the 执行上下文堆栈; asyncContext is now the 运行时执行上下文.
Resume the suspended 估值 of asyncContext. Let result be the value returned by the resumed computation.
Assert: When we return here, asyncContext has already been removed from the 执行上下文堆栈 and runningContext is the currently 运行时执行上下文.
Assert: result is a normal completion with a value of undefined. The possible sources of completion values are Await or, if the async function doesn't await anything, the step 3.g above.
Return.

26映射

26.1Reflect 对象

Reflect 对象 is the %Reflect% 内部对象 and the 初始值 of the Reflect property of the 全局对象. Reflect 对象 is an 普通对象.

[[Prototype]] 内部属性的值 of Reflect 对象 is the 内部对象 %ObjectPrototype%.

Reflect 对象 is not a 函数对象. It does not have a [[Construct]] 内部方法; it is not possible to use Reflect 对象 as a 构造器 with new 运算符. Reflect 对象 also does not have a [[Call]] 内部方法; it is not possible to invoke Reflect 对象 as a function.

26.1.1Reflect.apply ( `target`, `thisArgument`, `argumentsList` )

When the apply function is called with arguments target, thisArgument, and argumentsList, 执行如下:

If IsCallable(target) is false, 抛出一个 TypeError 异常.
Let args be ? CreateListFromArrayLike(argumentsList).
Perform PrepareForTailCall().
Return ? Call(target, thisArgument, args).

26.1.2Reflect.construct ( `target`, `argumentsList` [ , `newTarget` ] )

When the construct function is called with arguments target, argumentsList, and newTarget, 执行如下:

If IsConstructor(target) is false, 抛出一个 TypeError 异常.
If newTarget is not present, let newTarget be target.
Else if IsConstructor(newTarget) is false, 抛出一个 TypeError 异常.
Let args be ? CreateListFromArrayLike(argumentsList).
Return ? Construct(target, args, newTarget).

26.1.3Reflect.defineProperty ( `target`, `propertyKey`, `特性` )

When the defineProperty function is called with arguments target, propertyKey, and 特性, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
Let desc be ? ToPropertyDescriptor(特性).
Return ? target.[[DefineOwnProperty]](key, desc).

26.1.4Reflect.deleteProperty ( `target`, `propertyKey` )

When the deleteProperty function is called with arguments target and propertyKey, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
Return ? target.[[Delete]](key).

26.1.5Reflect.get ( `target`, `propertyKey` [ , `receiver` ] )

When the get function is called with arguments target, propertyKey, and receiver, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
If receiver is not present, then
1. Let receiver be target.
Return ? target.[[Get]](key, receiver).

26.1.6Reflect.getOwnPropertyDescriptor ( `target`, `propertyKey` )

When the getOwnPropertyDescriptor function is called with arguments target and propertyKey, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
Let desc be ? target.[[GetOwnProperty]](key).
Return FromPropertyDescriptor(desc).

26.1.7Reflect.getPrototypeOf ( `target` )

When the getPrototypeOf function is called with argument target, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Return ? target.[[GetPrototypeOf]]().

26.1.8Reflect.has ( `target`, `propertyKey` )

When the has function is called with arguments target and propertyKey, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
Return ? target.[[HasProperty]](key).

26.1.9Reflect.isExtensible ( `target` )

When the isExtensible function is called with argument target, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Return ? target.[[IsExtensible]]().

26.1.10Reflect.ownKeys ( `target` )

When the ownKeys function is called with argument target, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let keys be ? target.[[OwnPropertyKeys]]().
Return CreateArrayFromList(keys).

26.1.11Reflect.preventExtensions ( `target` )

When the preventExtensions function is called with argument target, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Return ? target.[[PreventExtensions]]().

26.1.12Reflect.set ( `target`, `propertyKey`, `V` [ , `receiver` ] )

When the set function is called with arguments target, V, propertyKey, and receiver, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
Let key be ? ToPropertyKey(propertyKey).
If receiver is not present, then
1. Let receiver be target.
Return ? target.[[Set]](key, V, receiver).

26.1.13Reflect.setPrototypeOf ( `target`, `proto` )

When the setPrototypeOf function is called with arguments target and proto, 执行如下:

If Type(target) is not Object, 抛出一个 TypeError 异常.
If Type(proto) is not Object and proto is not null, 抛出一个 TypeError 异常.
Return ? target.[[SetPrototypeOf]](proto).

26.2Proxy 对象

26.2.1The Proxy 构造器

The Proxy 构造器 is the %Proxy% 内部对象 and the 初始值 of the Proxy property of the 全局对象. When called as a 构造器它会创建和初始化一个新的 proxy 外来对象. Proxy is not intended to be called as a function and will 抛出一个异常 when called in that manner.

26.2.1.1Proxy ( `target`, `handler` )

When Proxy is called with arguments target and handler 执行如下:

If NewTarget is undefined, 抛出一个 TypeError 异常.
Return ? ProxyCreate(target, handler).

26.2.2Properties of the Proxy 构造器

[[Prototype]] 内部属性的值 of the Proxy 构造器 is the 内部对象 %FunctionPrototype%.

The Proxy 构造器 does not have a prototype property because proxy 外来对象 do not have a [[Prototype]] 内部属性 that requires initialization.

The Proxy 构造器有以下属性:

26.2.2.1Proxy.revocable ( `target`, `handler` )

The Proxy.revocable function is used to create a revocable 代理对象. When Proxy.revocable is called with arguments target and handler, 执行如下:

Let p be ? ProxyCreate(target, handler).
Let steps be the 算法步骤 defined in Proxy Revocation Functions.
Let revoker be CreateBuiltinFunction(steps, « [[RevocableProxy]] »).
Set revoker.[[RevocableProxy]] to p.
Let result be ObjectCreate(%ObjectPrototype%).
Perform CreateDataProperty(result, "proxy", p).
Perform CreateDataProperty(result, "revoke", revoker).
Return result.

26.2.2.1.1Proxy Revocation Functions

A Proxy revocation function is an 匿名函数 that has the ability to invalidate a specific 代理对象.

Each Proxy revocation function has a [[RevocableProxy]] 内部属性.

When a Proxy revocation function, F, is called, 执行如下:

Let p be F.[[RevocableProxy]].
If p is null, return undefined.
Set F.[[RevocableProxy]] to null.
Assert: p is a 代理对象.
Set p.[[ProxyTarget]] to null.
Set p.[[ProxyHandler]] to null.
Return undefined.

The length property of a Proxy revocation function is 0.

26.3模块命名空间对象

A 模块命名空间对象 is a module 命名空间外来对象 that provides runtime property-based access to a module's exported bindings. There is no 构造器 function for 模块命名空间对象. Instead, such an object is created for each module that is imported by an ImportDeclaration that includes a NameSpaceImport.

In addition to the properties specified in 9.4.6 each 模块命名空间对象 has the following 自身属性:

26.3.1@@toStringTag

The 初始值 of the @@toStringTag property is the String 值 "Module".

该属性拥有特性 { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.

27内存模型

The memory consistency model, or 内存模型, specifies the possible orderings of 共享数据块 events, arising via accessing TypedArray instances backed by a SharedArrayBuffer and via methods on Atomics 对象. When the program has no data races (defined below), the ordering of events appears as sequentially consistent, i.e., as an interleaving of actions from each agent. When the program has data races, shared memory operations may appear sequentially inconsistent. 例如, programs may exhibit causality-violating behaviour and other astonishments. These astonishments arise from compiler transforms and the design of CPUs (e.g., out-of-order execution and speculation). The 内存模型 defines both the precise conditions under which a program exhibits sequentially consistent behaviour as well as the possible values read from data races. To wit, there is no undefined behaviour.

The 内存模型 is defined as relational constraints on events introduced by 抽象操作 on SharedArrayBuffer or by methods on Atomics 对象 during an 估值.

Note

This section provides an axiomatic model on events introduced by the 抽象操作 on SharedArrayBuffers. It bears stressing that the model is not expressible algorithmically, unlike the rest of this specification. The nondeterministic 引言 of events by 抽象操作 is the interface between the operational 语义 of ES 估值 and the axiomatic 语义 of the 内存模型. The 语义 of these events is defined by considering graphs of all events in an 估值. These are neither 静态语义 nor 运行时语义. There is no demonstrated 算法实现, but instead a set of constraints that determine if a particular event graph is allowed or disallowed.

27.1内存模型基础

Shared memory accesses (reads and writes) are divided into two groups, atomic accesses and data accesses, defined below. Atomic accesses are sequentially consistent, i.e., there is a strict total ordering of events agreed upon by all 代理 in an agent cluster. Non-atomic accesses do not have a strict total ordering agreed upon by all 代理, i.e., unordered.

Note 1

No orderings weaker than sequentially consistent and stronger than unordered, 例如 release-acquire, are supported.

A 共享数据块 event is either a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory Record.

Table 73: ReadSharedMemory Event Fields

字段名	Value	Meaning
[[Order]]	`"SeqCst"` or `"Unordered"`	The weakest ordering guaranteed by the 内存模型 for the event.
[[NoTear]]	A Boolean	Whether this event is allowed to read from multiple write events on equal range as this event.
[[Block]]	A 共享数据块	The block the event operates on.
[[ByteIndex]]	一个非负整数	The byte address of the read in [[Block]].
[[ElementSize]]	一个非负整数	The size of the read.

Table 74: WriteSharedMemory Event Fields

字段名	Value	Meaning
[[Order]]	`"SeqCst"`, `"Unordered"`, or `"Init"`	The weakest ordering guaranteed by the 内存模型 for the event.
[[NoTear]]	A Boolean	Whether this event is allowed to be read from multiple read events with equal range as this event.
[[Block]]	A 共享数据块	The block the event operates on.
[[ByteIndex]]	一个非负整数	The byte address of the write in [[Block]].
[[ElementSize]]	一个非负整数	The size of the write.
[[Payload]]	A List	The List of byte values to be read by other events.

Table 75: ReadModifyWriteSharedMemory Event Fields

字段名	Value	Meaning
[[Order]]	`"SeqCst"`	Read-modify-write events are always sequentially consistent.
[[NoTear]]	true	Read-modify-write events cannot tear.
[[Block]]	A 共享数据块	The block the event operates on.
[[ByteIndex]]	一个非负整数	The byte address of the read-modify-write in [[Block]].
[[ElementSize]]	一个非负整数	The size of the read-modify-write.
[[Payload]]	A List	The List of byte values to be passed to [[ModifyOp]].
[[ModifyOp]]	A semantic function	A pure semantic function that returns a modified List of byte values from a read List of byte values and [[Payload]].

These events are introduced by 抽象操作 or by methods on Atomics 对象.

In addition to 共享数据块 events, there are host-specific events.

Let the range of a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event be the Set of contiguous integers from its [[ByteIndex]] to [[ByteIndex]]+[[ElementSize]]-1. Two events' ranges are equal when the events have the same [[Block]], and the ranges are element-wise equal. Two events' ranges are overlapping when the events have the same [[Block]], the ranges are not equal and their intersection is non-empty. Two events' ranges are disjoint when the events do not have the same [[Block]] or their ranges are neither equal nor overlapping.

Note 2

Examples of host-specific synchronizing events that should be accounted for are: sending a SharedArrayBuffer from one agent to another (e.g., by postMessage in a browser), starting and stopping 代理, and communicating within the agent cluster via channels other than shared memory. It is assumed those events are appended to agent-order during 估值 like the other SharedArrayBuffer events.

共享数据块 events are ordered within candidate executions by the relations defined below.

27.2代理事件记录

An Agent Events Record is a Record with the following fields.

Table 76: Agent Events Record Fields

字段名	Value	Meaning
[[AgentSignifier]]	A value that admits equality testing	The agent whose 估值 resulted in this ordering.
[[EventList]]	A List of events	Events are appended to the list during 估值.

27.3Chosen Value Records

A Chosen Value Record is a Record with the following fields.

Table 77: Chosen Value Record Fields

字段名	Value	Meaning
[[Event]]	A 共享数据块 event	The ReadSharedMemory or ReadModifyWriteSharedMemory event that was introduced for this chosen value.
[[ChosenValue]]	A List of byte values	The bytes that were nondeterministically chosen during 估值.

27.4Candidate Executions

A candidate execution of the 估值 of an agent cluster is a Record with the following fields.

Table 78: Candidate Execution Record Fields

字段名	Value	Meaning
[[EventLists]]	A List of Agent Events Records.	Maps an agent to Lists of events appended during the 估值.
[[ChosenValues]]	A List of Chosen Value Records.	Maps ReadSharedMemory or ReadModifyWriteSharedMemory events to the List of byte values chosen during the 估值.
[[AgentOrder]]	An agent-order Relation.	Defined below.
[[ReadsBytesFrom]]	A reads-bytes-from semantic function.	Defined below.
[[ReadsFrom]]	A reads-from Relation.	Defined below.
[[HostSynchronizesWith]]	A host-synchronizes-with Relation.	Defined below.
[[SynchronizesWith]]	A synchronizes-with Relation.	Defined below.
[[HappensBefore]]	A happens-before Relation.	Defined below.

An empty candidate execution is a candidate execution Record whose fields are empty Lists and Relations.

27.5内存模型的抽象操作

27.5.1EventSet( `execution` )

The 抽象操作 EventSet takes one argument, a candidate execution execution. It 执行如下:

Let events be an empty Set.
For each Agent Events Record aer in execution.[[EventLists]], do
1. For each event E in aer.[[EventList]], do
  1. Add E to events.
Return events.

27.5.2SharedDataBlockEventSet( `execution` )

The 抽象操作 SharedDataBlockEventSet takes one argument, a candidate execution execution. It 执行如下:

Let events be an empty Set.
For each event E in EventSet(execution), do
1. If E is a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event, add E to events.
Return events.

27.5.3HostEventSet( `execution` )

The 抽象操作 HostEventSet takes one argument, a candidate execution execution. It 执行如下:

Let events be an empty Set.
For each event E in EventSet(execution), do
1. If E is not in SharedDataBlockEventSet(execution), add E to events.
Return events.

27.5.4ComposeWriteEventBytes( `execution`, `byteIndex`, `Ws` )

The 抽象操作 ComposeWriteEventBytes takes four arguments, a candidate execution execution, 一个非负整数 byteIndex, and a List Ws of WriteSharedMemory or ReadModifyWriteSharedMemory events. It 执行如下:

Let byteLocation be byteIndex.
Let bytesRead be a new empty List.
For each element W of Ws in List order, do
1. Assert: W has byteLocation in its range.
2. Let payloadIndex be byteLocation - W.[[ByteIndex]].
3. If W is a WriteSharedMemory event, then
  1. Let byte be W.[[Payload]][payloadIndex].
4. Else,
  1. Assert: W is a ReadModifyWriteSharedMemory event.
  2. Let bytes be ValueOfReadEvent(execution, W).
  3. Let bytesModified be W.[[ModifyOp]](bytes, W.[[Payload]]).
  4. Let byte be bytesModified[payloadIndex].
5. Append byte to bytesRead.
6. Increment byteLocation by 1.
Return bytesRead.

Note 1

The semantic function [[ModifyOp]] is given by the function properties on Atomics 对象 that introduce ReadModifyWriteSharedMemory events.

Note 2

This 抽象操作 composes a List of write events into a List of byte values. It is used in the event 语义 of ReadSharedMemory and ReadModifyWriteSharedMemory events.

27.5.5ValueOfReadEvent( `execution`, `R` )

The 抽象操作 ValueOfReadEvent takes two arguments, a candidate execution execution and a ReadSharedMemory or ReadModifyWriteSharedMemory event R. It 执行如下:

Assert: R is a ReadSharedMemory or ReadModifyWriteSharedMemory event.
Let Ws be execution.[[ReadsBytesFrom]](R).
Assert: Ws is a List of WriteSharedMemory or ReadModifyWriteSharedMemory events with length equal to R.[[ElementSize]].
Return ComposeWriteEventBytes(execution, R.[[ByteIndex]], Ws).

27.6Relations of Candidate Executions

27.6.1agent-order

For a candidate execution execution, execution.[[AgentOrder]] is a Relation on events that satisfies the following.

For each pair (E, D) in EventSet(execution), (E, D) is in execution.[[AgentOrder]] if there is some Agent Events Record aer in execution.[[EventLists]] such that E and D are in aer.[[EventList]] and E is before D in List order of aer.[[EventList]].

Note

Each agent introduces events in a per-agent strict total order during the 估值. This is the union of those strict total orders.

27.6.2reads-bytes-from

For a candidate execution execution, execution.[[ReadsBytesFrom]] is a semantic function from events in SharedDataBlockEventSet(execution) to Lists of events in SharedDataBlockEventSet(execution) that satisfies the following conditions.

For each ReadSharedMemory or ReadModifyWriteSharedMemory event R in SharedDataBlockEventSet(execution), execution.[[ReadsBytesFrom]](R) is a List of length equal to R.[[ElementSize]] of WriteSharedMemory or ReadModifyWriteSharedMemory events Ws such that all of the following are true.
- Each event W with index i in Ws has R.[[ByteIndex]]+i in its range.
- R is not in Ws.

27.6.3reads-from

For a candidate execution execution, execution.[[ReadsFrom]] is the least Relation on events that satisfies the following.

For each pair (R, W) in SharedDataBlockEventSet(execution), (R, W) is in execution.[[ReadsFrom]] if W is in execution.[[ReadsBytesFrom]](R).

27.6.4host-synchronizes-with

For a candidate execution execution, execution.[[HostSynchronizesWith]] is a host-provided strict partial order on host-specific events that satisfies at least the following.

If (E, D) is in execution.[[HostSynchronizesWith]], E and D are in HostEventSet(execution).
There is no cycle in the union of execution.[[HostSynchronizesWith]] and execution.[[AgentOrder]].

Note 1

For two host-specific events E and D, E host-synchronizes-with D implies E happens-before D.

Note 2

The host-synchronizes-with relation allows the host to provide additional synchronization mechanisms, 例如 postMessage between HTML workers.

27.6.5synchronizes-with

For a candidate execution execution, execution.[[SynchronizesWith]] is the least Relation on events that satisfies the following.

For each pair (R, W) in execution.[[ReadsFrom]], (W, R) is in execution.[[SynchronizesWith]] if all the following are true.
- R.[[Order]] is "SeqCst".
- W.[[Order]] is "SeqCst" or "Init".
- If W.[[Order]] is "SeqCst", then R and W have equal ranges.
- If W.[[Order]] is "Init", then for each event V such that (R, V) is in execution.[[ReadsFrom]], V.[[Order]] is "Init".
For each pair (E, D) in execution.[[HostSynchronizesWith]], (E, D) is in execution.[[SynchronizesWith]].

Note 1

Owing to convention, write events synchronizes-with read events, instead of read events synchronizes-with write events.

Note 2

Not all "SeqCst" events related by reads-from are related by synchronizes-with. Only events that also have equal ranges are related by synchronizes-with.

Note 3

For an event R and an event W such that W synchronizes-with R, R may reads-from other writes than W.

27.6.6happens-before

For a candidate execution execution, execution.[[HappensBefore]] is the least Relation on events that satisfies the following.

For each pair (E, D) in execution.[[AgentOrder]], (E, D) is in execution.[[HappensBefore]].
For each pair (E, D) in execution.[[SynchronizesWith]], (E, D) is in execution.[[HappensBefore]].
For each pair (E, D) in SharedDataBlockEventSet(execution), (E, D) is in execution.[[HappensBefore]] if E.[[Order]] is "Init" and E and D have overlapping ranges.
For each pair (E, D) in EventSet(execution), (E, D) is in execution.[[HappensBefore]] if there is an event F such that the pairs (E, F) and (F, D) are in execution.[[HappensBefore]].

Note

Because happens-before is a superset of agent-order, candidate executions are consistent with the single-thread 估值语义 of ES.

27.7Properties of Valid Executions

27.7.1Valid Chosen Reads

A candidate execution execution has valid chosen reads if the following 抽象操作 returns true.

For each ReadSharedMemory or ReadModifyWriteSharedMemory event R in SharedDataBlockEventSet(execution), do
1. Let chosenValue be the element of execution.[[ChosenValues]] whose [[Event]] field is R.
2. Let readValue be ValueOfReadEvent(execution, R).
3. Let chosenLen be the number of elements of chosenValue.
4. Let readLen be the number of elements of readValue.
5. If chosenLen is not equal to readLen, then
  1. Return false.
6. If chosenValue[i] is not equal to readValue[i] for any integer value i in the range 0 through chosenLen, exclusive, then
  1. Return false.
7. Return true.

27.7.2Coherent Reads

A candidate execution execution has coherent reads if the following 抽象操作 returns true.

For each ReadSharedMemory or ReadModifyWriteSharedMemory event R in SharedDataBlockEventSet(execution), do
1. Let Ws be execution.[[ReadsBytesFrom]](R).
2. Let byteLocation be R.[[ByteIndex]].
3. For each element W of Ws in List order, do
  1. If (R, W) is in execution.[[HappensBefore]], then
    1. Return false.
  2. If there is a WriteSharedMemory or ReadModifyWriteSharedMemory event V that has byteLocation in its range such that the pairs (W, V) and (V, R) are in execution.[[HappensBefore]], then
    1. Return false.
  3. Increment byteLocation by 1.
4. Return true.

27.7.3Tear Free Reads

A candidate execution execution has tear free reads if the following 抽象操作 returns true.

For each ReadSharedMemory or ReadModifyWriteSharedMemory event R in SharedDataBlockEventSet(execution), do
1. If R.[[NoTear]] is true, then
  1. Assert: The remainder of dividing R.[[ByteIndex]] by R.[[ElementSize]] is 0.
  2. For each event W such that (R, W) is in execution.[[ReadsFrom]] and W.[[NoTear]] is true, do
    1. If R and W have equal ranges, and there is an event V such that V and W have equal ranges, V.[[NoTear]] is true, W is not V, and (R, V) is in execution.[[ReadsFrom]], then
      1. Return false.
Return true.

Note

An event's [[NoTear]] field is true when that event was introduced via accessing an integer TypedArray, and false when introduced via accessing a floating point TypedArray or DataView.

Intuitively, this requirement says when a memory range is accessed in an aligned fashion via an integer TypedArray, a single write event on that range must "win" when in a data race with other write events with equal ranges. More precisely, this requirement says an aligned read event cannot read a value composed of bytes from multiple, different write events all with equal ranges. It is possible, however, for an aligned read event to read from multiple write events with overlapping ranges.

27.7.4Sequentially Consistent Atomics

For a candidate execution execution, memory-order is a strict total order of all events in EventSet(execution) that satisfies the following.

For each pair (E, D) in execution.[[HappensBefore]], (E, D) is in memory-order.
For each pair (E, D) in execution.[[SynchronizesWith]], (E, D) is in memory-order if there is no WriteSharedMemory or ReadModifyWriteSharedMemory event W in SharedDataBlockEventSet(execution) with equal range as D such that W is not E, and the pairs (E, W) and (W, D) are in memory-order.
Note 1

This clause additionally constrains "SeqCst" events on equal ranges.
For each WriteSharedMemory or ReadModifyWriteSharedMemory event W in SharedDataBlockEventSet(execution), if W.[[Order]] is "SeqCst", then it is not the case that there is an infinite number of ReadSharedMemory or ReadModifyWriteSharedMemory events in SharedDataBlockEventSet(execution) with equal range that is memory-order before W.
Note 2

This clause together with the forward progress guarantee on 代理 ensure the liveness condition that "SeqCst" writes become visible to "SeqCst" reads with equal range in finite time.

A candidate execution has sequentially consistent atomics if a memory-order exists.

Note 3

While memory-order includes all events in EventSet(execution), those that are not constrained by happens-before or synchronizes-with are allowed to occur anywhere in the order.

27.7.5Valid Executions

A candidate execution execution is a valid execution (or simply an execution) if all of the following are true.

The host provides a host-synchronizes-with Relation for execution.[[HostSynchronizesWith]].
execution.[[HappensBefore]] is a strict partial order.
execution has valid chosen reads.
execution has coherent reads.
execution has tear free reads.
execution has sequentially consistent atomics.

All programs have at least one valid execution.

27.8Races

For an execution execution, two events E and D in SharedDataBlockEventSet(execution) are in a race if the following 抽象操作 returns true.

If E is not D, then
1. If the pairs (E, D) and (D, E) are not in execution.[[HappensBefore]], then
  1. If E and D are both WriteSharedMemory or ReadModifyWriteSharedMemory events and E and D do not have disjoint ranges, then
    1. Return true.
  2. If either (E, D) or (D, E) is in execution.[[ReadsFrom]], then
    1. Return true.
Return false.

27.9Data Races

For an execution execution, two events E and D in SharedDataBlockEventSet(execution) are in a data race if the following 抽象操作 returns true.

If E and D are in a race in execution, then
1. If E.[[Order]] is not "SeqCst" or D.[[Order]] is not "SeqCst", then
  1. Return true.
2. If E and D have overlapping ranges, then
  1. Return true.
Return false.

27.10Data Race Freedom

An execution execution is data race free if there are no two events in SharedDataBlockEventSet(execution) that are in a data race.

A program is data race free if all its executions are data race free.

The 内存模型 guarantees sequential consistency of all events for data race free programs.

27.11Shared Memory Guidelines

Note 1

The following are guidelines for ES programmers working with shared memory.

We recommend programs be kept data race free, i.e., make it so that it is impossible for there to be concurrent non-atomic operations on the same memory location. Data race free programs have interleaving 语义 where each step in the 估值语义 of each agent are interleaved with each other. For data race free programs, it is not necessary to understand the details of the 内存模型. The details are unlikely to build intuition that will help one to better write ES.

More generally, even if a program is not data race free it may have predictable behaviour, so long as atomic operations are not involved in any data races and the operations that race all have the same access size. The simplest way to arrange for atomics not to be involved in races is to ensure that different memory cells are used by atomic and non-atomic operations and that atomic accesses of different sizes are not used to access the same cells at the same time. Effectively, the program should treat shared memory as strongly typed as much as possible. One still cannot depend on the ordering and timing of non-atomic accesses that race, but if memory is treated as strongly typed the racing accesses will not "tear" (bits of their values will not be mixed).

Note 2

The following are guidelines for ES implementers writing compiler transformations for programs using shared memory.

It is desirable to allow most program transformations that are valid in a single-agent setting in a multi-agent setting, to ensure that the performance of each agent in a multi-agent program is as good as it would be in a single-agent setting. Frequently these transformations are hard to judge. We outline some rules about program transformations that are intended to be taken as normative (in that they are implied by the 内存模型 or stronger than what the 内存模型 implies) but which are likely not exhaustive. These rules are intended to apply to program transformations that precede the introductions of the events that make up the agent-order.

Let an agent-order slice be the subset of the agent-order pertaining to a single agent.

Let possible read values of a read event be the set of all values of ValueOfReadEvent for that event across all valid executions.

Any transformation of an agent-order slice that is valid in the absence of shared memory is valid in the presence of shared memory, with the following exceptions.

Atomics are carved in stone: Program transformations must not cause the "SeqCst" events in an agent-order slice to be reordered with its "Unordered" operations, nor its "SeqCst" operations to be reordered with each other, nor may a program transformation remove a "SeqCst" operation from the agent-order.

(In practice, the prohibition on reorderings forces a compiler to assume that every "SeqCst" operation is a synchronization and included in the final memory-order, which it would usually have to assume anyway in the absence of inter-agent program analysis. It also forces the compiler to assume that every call where the callee's effects on the memory-order are unknown may contain "SeqCst" operations.)
Reads must be stable: Any given shared memory read must only observe a single value in an execution.

(例如, if what is semantically a single read in the program is executed multiple times then the program is subsequently allowed to observe only one of the values read. A transformation known as rematerialization can violate this rule.)
Writes must be stable: All observable writes to shared memory must follow from program 语义 in an execution.

(例如, a transformation may not introduce certain observable writes, 例如 by using read-modify-write operations on a larger location to write a smaller datum, writing a value to memory that the program could not have written, or writing a just-read value back to the location it was read from, if that location could have been overwritten by another agent after the read.)
Possible read values must be nonempty: Program transformations cannot cause the possible read values of a shared memory read to become empty.

(Counterintuitively, this rule in effect restricts transformations on writes, because writes have force in 内存模型 insofar as to be read by read events. 例如, writes may be moved and coalesced and sometimes reordered between two "SeqCst" operations, but the transformation may not remove every write that updates a location; some write must be preserved.)

Examples of transformations that remain valid are: merging multiple non-atomic reads from the same location, reordering non-atomic reads, introducing speculative non-atomic reads, merging multiple non-atomic writes to the same location, reordering non-atomic writes to different locations, and hoisting non-atomic reads out of loops even if that affects termination. Note in general that aliased TypedArrays make it hard to prove that locations are different.

Note 3

The following are guidelines for ES implementers generating machine code for shared memory accesses.

For architectures with memory models no weaker than those of ARM or Power, non-atomic stores and loads may be compiled to bare stores and loads on the target architecture. Atomic stores and loads may be compiled down to instructions that guarantee sequential consistency. If no such instructions exist, memory barriers are to be employed, 例如 placing barriers on both sides of a bare store or load. Read-modify-write operations may be compiled to read-modify-write instructions on the target architectrue, 例如 LOCK-prefixed instructions on x86, load-exclusive/store-exclusive instructions on ARM, and load-link/store-conditional instructions on Power.

Specifically, the 内存模型 is intended to allow code generation as follows.

Every atomic operation in the program is assumed to be necessary.
Atomic operations are never rearranged with each other or with non-atomic operations.
Functions are always assumed to perform atomic operations.
Atomic operations are never implemented as read-modify-write operations on larger data, but as non-lock-free atomics if the platform does not have atomic operations of the appropriate size. (We already assume that every platform has normal memory access operations of every interesting size.)

Naive code generation uses these 模式:

Regular loads and stores compile to single load and store instructions.
Lock-free atomic loads and stores compile to a full (sequentially consistent) fence, a regular load or store, and a full fence.
Lock-free atomic read-modify-write accesses compile to a full fence, an atomic read-modify-write instruction sequence, and a full fence.
Non-lock-free atomics compile to a spinlock acquire, a full fence, a series of non-atomic load and store instructions, a full fence, and a spinlock release.

That mapping is correct so long as an atomic operation on an address range does not race with a non-atomic write or with an atomic operation of different size. However, that is all we need: the 内存模型 effectively demotes the atomic operations involved in a race to non-atomic status. On the other hand, the naive mapping is quite strong: it allows atomic operations to be used as sequentially consistent fences, which the 内存模型 does not actually guarantee.

A number of local improvements to those basic 模式 are also intended to be legal:

There are obvious platform-dependent improvements that remove redundant fences. 例如, on x86 the fences around lock-free atomic loads and stores can always be omitted except for the fence following a store, and no fence is needed for lock-free read-modify-write instructions, as these all use LOCK-prefixed instructions. On many platforms there are fences of several strengths, and weaker fences can be used in certain contexts without destroying sequential consistency.
Most modern platforms support lock-free atomics for all the data sizes required by ES atomics. Should non-lock-free atomics be needed, the fences surrounding the body of the atomic operation can usually be folded into the lock and unlock steps. The simplest solution for non-lock-free atomics is to have a single lock word per SharedArrayBuffer.
There are also more complicated platform-dependent local improvements, requiring some code analysis. 例如, two back-to-back fences often have the same effect as a single fence, so if code is generated for two atomic operations in sequence, only a single fence need separate them. On x86, even a single fence separating atomic stores can be omitted, as the fence following a store is only needed to separate the store from a subsequent load.

A文法摘要

A.1词法

any Unicode 码点

InputElementRegExpOrTemplateTail

InputElementTemplateTail

WhiteSpace

<TAB>

<VT>

<FF>

<SP>

<NBSP>

<USP>

LineTerminator

<LF>

<CR>

<LS>

<PS>

<LF>

<CR>

[lookahead ≠ <LF>]

<LS>

<PS>

<CR>

<LF>

opt

opt

opt

opt

opt

but not *

but not one of / or *

SingleLineComment

opt

opt

but not LineTerminator

<ZWNJ>

<ZWJ>

UnicodeIDStart

any Unicode 码点 with the Unicode property “ID_Start”

any Unicode 码点 with the Unicode property “ID_Continue”

one of

await

break

case

catch

class

const

continue

debugger

default

delete

else

export

extends

finally

for

function

import

instanceof

new

return

super

switch

this

throw

try

typeof

var

void

while

with

yield

FutureReservedWord

enum

The following tokens are also considered to be FutureReservedWords when parsing 严格模式代码:

implements package protected
interface private public

Punctuator

one of

{

(

)

[

]

...

;

===

!==

>>>

**=

<<=

>>=

>>>=

}

null

true

false

opt

opt

opt

ExponentPart

opt

opt

one of

one of

one of

one of

one of

one of

opt

opt

opt

opt

but not one of " or \ or LineTerminator

but not one of ' or \ or LineTerminator

[lookahead ∉ DecimalDigit]

one of

but not one of EscapeCharacter or LineTerminator

EscapeCharacter

}

[empty]

but not one of * or \ or / or [

but not one of \ or / or [

but not LineTerminator

[

]

[empty]

RegularExpressionClassChar

but not one of ] or \

[empty]

Template

opt

opt

}

opt

}

opt

opt

[lookahead ≠ {]

but not one of ` or \ or $ or LineTerminator

A.2表达式

[Yield, Await]

[~Yield]

yield

[~Await]

await

[Yield, Await]

yield

await

but not ReservedWord

[Yield]

[?Yield, +Await]

[Yield, Await]

[~Yield]

yield

[~Await]

await

[Yield, Await]

this

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, ~Tagged]

[?Yield, ?Await]

[Yield, Await]

(

[+In, ?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

)

(

)

(

...

[?Yield, ?Await]

)

(

...

[?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

...

[?Yield, ?Await]

)

(

[+In, ?Yield, ?Await]

...

[?Yield, ?Await]

)

When processing an instance of the production PrimaryExpression[Yield, Await]:CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await] the interpretation of CoverParenthesizedExpressionAndArrowParameterList is refined using the following grammar:

[Yield, Await]

(

[+In, ?Yield, ?Await]

)

[Yield, Await]

[

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

]

[Yield, Await]

opt

[+In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?Yield, ?Await]

opt

[+In, ?Yield, ?Await]

[?Yield, ?Await]

opt

[?Yield, ?Await]

[Yield, Await]

...

[+In, ?Yield, ?Await]

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[

[+In, ?Yield, ?Await]

]

CoverInitializedName

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[Yield, Await, Tagged]

[?Yield, ?Await, ?Tagged]

[Yield, Await, Tagged]

[?Yield, ?Await, ?Tagged]

[Yield, Await, Tagged]

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Tagged]

[+In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[

[+In, ?Yield, ?Await]

]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, +Tagged]

[?Yield, ?Await]

new

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

super

[

[+In, ?Yield, ?Await]

]

super

MetaProperty

NewTarget

new

target

[Yield, Await]

[?Yield, ?Await]

new

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[

[+In, ?Yield, ?Await]

]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, +Tagged]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

When processing an instance of the production CallExpression[Yield, Await]:CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await] the interpretation of CoverCallExpressionAndAsyncArrowHead is refined using the following grammar:

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

super

[?Yield, ?Await]

[Yield, Await]

(

)

(

[?Yield, ?Await]

)

(

[?Yield, ?Await]

)

[Yield, Await]

[+In, ?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

...

[+In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[no LineTerminator here]

[?Yield, ?Await]

[no LineTerminator here]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

delete

[?Yield, ?Await]

void

[?Yield, ?Await]

typeof

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+Await]

AwaitExpression

[?Yield]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

one of

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

>>>

[?Yield, ?Await]

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

instanceof

[?Yield, ?Await]

[+In]

[+In, ?Yield, ?Await]

[?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

===

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

!==

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

[+Yield]

[?In, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

In certain circumstances when processing an instance of the production AssignmentExpression[In, Yield, Await]:LeftHandSideExpression[?Yield, ?Await]=AssignmentExpression[?In, ?Yield, ?Await] the following grammar is used to refine the interpretation of LeftHandSideExpression:

AssignmentPattern

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

[?Yield, ?Await]

opt

}

[Yield, Await]

[

opt

[?Yield, ?Await]

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

[?Yield, ?Await]

opt

]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

...

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

one of

<<=

>>=

>>>=

**=

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

A.3语句

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await]

[+Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await, ~Default]

[?Yield, ?Await, ~Default]

[+In, ?Yield, ?Await]

[Yield, Await, Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[?Yield, ?Await, ?Default]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

{

[?Yield, ?Await, ?Return]

opt

}

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await]

[In, Yield, Await]

[?In, ?Yield, ?Await]

;

let

const

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[Yield, Await]

var

[+In, ?Yield, ?Await]

;

[In, Yield, Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[?In, ?Yield, ?Await]

[In, Yield, Await]

[?Yield, ?Await]

[?In, ?Yield, ?Await]

opt

[?Yield, ?Await]

[?In, ?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

{

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

}

{

[?Yield, ?Await]

[?Yield, ?Await]

opt

}

[Yield, Await]

[

opt

[?Yield, ?Await]

opt

]

[

[?Yield, ?Await]

]

[

[?Yield, ?Await]

opt

[?Yield, ?Await]

opt

]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

[Yield, Await]

...

[?Yield, ?Await]

...

[?Yield, ?Await]

EmptyStatement

;

[Yield, Await]

[lookahead ∉ { {, function, async

[no LineTerminator here]

function, class, let [ }]

[+In, ?Yield, ?Await]

;

[Yield, Await, Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

else

[?Yield, ?Await, ?Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

while

(

[+In, ?Yield, ?Await]

)

;

while

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[~In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

var

[~In, ?Yield, ?Await]

;

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

[~In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

opt

;

[+In, ?Yield, ?Await]

opt

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ∉ { let [ }]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

for

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[lookahead ≠ let]

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

var

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[+Await]

for

await

(

[?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

continue

;

continue

[no LineTerminator here]

[?Yield, ?Await]

;

[Yield, Await]

break

;

break

[no LineTerminator here]

[?Yield, ?Await]

;

[Yield, Await]

return

;

return

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

[Yield, Await, Return]

with

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

switch

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

{

[?Yield, ?Await, ?Return]

opt

}

{

[?Yield, ?Await, ?Return]

opt

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

opt

}

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

case

[+In, ?Yield, ?Await]

[?Yield, ?Await, ?Return]

opt

[Yield, Await, Return]

default

[?Yield, ?Await, ?Return]

opt

[Yield, Await, Return]

[?Yield, ?Await]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ~Default]

[Yield, Await]

throw

[no LineTerminator here]

[+In, ?Yield, ?Await]

;

[Yield, Await, Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

try

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

catch

(

[?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

[Yield, Await, Return]

finally

[?Yield, ?Await, ?Return]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

debugger

;

A.4函数和类

[Yield, Await, Default]

function

[?Yield, ?Await]

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[+Default]

function

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

function

[~Yield, ~Await]

opt

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[empty]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await, +Return]

opt

[In, Yield, Await]

[?Yield, ?Await]

[no LineTerminator here]

[?In]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[In]

[lookahead ≠ {]

[?In, ~Yield, ~Await]

{

[~Yield, ~Await]

}

When the production ArrowParameters[Yield, Await]:CoverParenthesizedExpressionAndArrowParameterList[?Yield, ?Await] is recognized the following grammar is used to refine the interpretation of CoverParenthesizedExpressionAndArrowParameterList:

[Yield, Await]

(

[?Yield, ?Await]

)

[In, Yield, Await]

async

[no LineTerminator here]

[?Yield]

[no LineTerminator here]

[?In]

[?Yield, ?Await]

[no LineTerminator here]

[?In]

[In]

[lookahead ≠ {]

[?In, ~Yield, +Await]

{

}

When the production AsyncArrowFunction[In, Yield, Await]:CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator here]=>AsyncConciseBody[?In] is recognized the following grammar is used to refine the interpretation of CoverParenthesizedExpressionAndArrowParameterList:

AsyncArrowHead

async

[no LineTerminator here]

[~Yield, +Await]

[Yield, Await]

[?Yield, ?Await]

(

[~Yield, ~Await]

)

{

[~Yield, ~Await]

}

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

get

[?Yield, ?Await]

(

)

{

[~Yield, ~Await]

}

set

[?Yield, ?Await]

(

)

{

[~Yield, ~Await]

}

[~Yield, ~Await]

[Yield, Await]

[?Yield, ?Await]

(

[+Yield, ~Await]

)

{

}

[Yield, Await, Default]

function

[?Yield, ?Await]

(

[+Yield, ~Await]

)

{

}

[+Default]

function

(

[+Yield, ~Await]

)

{

}

function

[+Yield, ~Await]

opt

(

[+Yield, ~Await]

)

{

}

[+Yield, ~Await]

[In, Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

yield

[no LineTerminator here]

[?In, +Yield, ?Await]

[Yield, Await]

async

[no LineTerminator here]

[?Yield, ?Await]

(

[~Yield, +Await]

)

{

}

[Yield, Await, Default]

async

[no LineTerminator here]

function

[?Yield, ?Await]

(

[~Yield, +Await]

)

{

}

[+Default]

async

[no LineTerminator here]

function

(

[~Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

(

[~Yield, +Await]

)

{

}

async

[no LineTerminator here]

function

[~Yield, +Await]

(

[~Yield, +Await]

)

{

}

[~Yield, +Await]

[Yield]

await

[?Yield, +Await]

[Yield, Await, Default]

class

[?Yield, ?Await]

[?Yield, ?Await]

[+Default]

class

[?Yield, ?Await]

[Yield, Await]

class

[?Yield, ?Await]

opt

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

opt

{

[?Yield, ?Await]

opt

}

[Yield, Await]

extends

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

[?Yield, ?Await]

[?Yield, ?Await]

[Yield, Await]

[?Yield, ?Await]

static

[?Yield, ?Await]

;

A.5脚本和模块

opt

[~Yield, ~Await, ~Return]

opt

[~Yield, ~Await, ~Return]

import

;

import

;

{

}

{

}

{

}

from

[~Yield, ~Await]

export

;

export

;

export

;

export

[~Yield, ~Await]

export

[~Yield, ~Await]

export

default

[~Yield, ~Await, +Default]

export

default

[~Yield, ~Await, +Default]

export

default

[lookahead ∉ { function, async

[no LineTerminator here]

function, class }]

[+In, ~Yield, ~Await]

;

{

}

{

StrUnsignedDecimalLiteral

}

{

}

A.6数值转换

:::

opt

opt

opt

:::

opt

:::

:::

:::

:::

Infinity

opt

opt

opt

opt

one of

one of

one of

All grammar symbols not explicitly defined by the StringNumericLiteral grammar have the definitions used in the 词法 for 数值型字面量.

A.7通用资源标识符字符类

:::

opt

:::

opt

:::

:::

one of

;

:::

:::

:::

one of

uriMark

:::

one of

(

)

A.8正则表达式

[U, N]

[?U, ?N]

[U, N]

[?U, ?N]

[?U, ?N]

[?U, ?N]

[U, N]

[empty]

[?U, ?N]

[?U, ?N]

[U, N]

[?U, ?N]

[?U, ?N]

[?U, ?N]

[U, N]

(

[?U, ?N]

)

(

[?U, ?N]

)

(

[?U, ?N]

)

(

[?U, ?N]

)

QuantifierPrefix

{

}

{

}

{

}

[U, N]

[?U, ?N]

[?U]

(

GroupSpecifier

[?U]

[?U, ?N]

)

(

[?U, ?N]

)

one of

(

)

[

]

{

}

PatternCharacter

but not SyntaxCharacter

[U, N]

[?U]

[?U]

[+N]

[?U]

[U]

[lookahead ∉ DecimalDigit]

[?U]

[?U]

ControlEscape

one of

one of

[U]

[+U]

[+U]

[+U]

[+U]

[~U]

[+U]

}

but only if the SV of Hex4Digits is in the inclusive range 0xD800 to 0xDBFF

but only if the SV of Hex4Digits is in the inclusive range 0xDC00 to 0xDFFF

NonSurrogate

but only if the SV of Hex4Digits is not in the inclusive range 0xD800 to 0xDFFF

[U]

[+U]

[+U]

[~U]

but not UnicodeIDContinue

opt

[lookahead ∉ DecimalDigit]

[U]

[+U]

}

[+U]

}

CharacterClass

[U]

[

[lookahead ∉ { ^ }]

[?U]

]

[

[?U]

]

[U]

[empty]

[?U]

[U]

[?U]

[?U]

[?U]

[?U]

[?U]

[?U]

[U]

[?U]

[?U]

[?U]

[?U]

[?U]

[?U]

[U]

[?U]

[U]

but not one of \ or ] or -

[?U]

[U]

[+U]

[?U]

LegacyOctalIntegerLiteral

[?U]

BWeb 浏览器附加的 ES 的特点

当 ES 的宿主是 web 浏览器时，定义在本附录中的 ES 语言的语法和语义是被需要的。如果 ES 宿主不是一个 web 浏览器，那么本附录中的内容是规范的但可选的。

Note

本附录描述了各种传统的特征和基于 ES 实现的 web 浏览器的特征。本附录中指定的所有语言特性和行为中都有一个或多个不希望出现的特征，如果没有遗留使用，那么将会从该规范中删除。然而，这些特性被大量的现有网页使用，意味着 web 浏览器必须继续支持它们。本附录中的规范定义了这些遗留特征的互操作实现的要求。

这些功能都不被认为是 ES 语言核心的一部分。当在写新的 ES 代码时，程序员不应使用或假定这些特征和行为的存在。ES 实现不鼓励实现这些功能，除非该实现是 web 浏览器的一部分或是被需要用来运行浏览器所遇到的相同的遗留 ES 代码。

B.1附加的句法

B.1.1数值型字面量

除非这些扩展不被严格模式代码所允许，否则，11.8.3 中的语法和语义会被扩展如下：

Syntax

LegacyOctalIntegerLiteral

NonOctalDecimalIntegerLiteral

opt

NonOctalDigit

LegacyOctalLikeDecimalIntegerLiteral

NonOctalDigit

NonOctalDecimalIntegerLiteral

LegacyOctalLikeDecimalIntegerLiteral

LegacyOctalLikeDecimalIntegerLiteral

NonOctalDigit

one of

B.1.1.1静态语义

The MV of LegacyOctalIntegerLiteral::0OctalDigit is the MV of OctalDigit.
The MV of LegacyOctalIntegerLiteral::LegacyOctalIntegerLiteralOctalDigit is (the MV of LegacyOctalIntegerLiteral times 8) plus the MV of OctalDigit.
The MV of DecimalIntegerLiteral::NonOctalDecimalIntegerLiteral is the MV of NonOctalDecimalIntegerLiteral.
The MV of NonOctalDecimalIntegerLiteral::0NonOctalDigit is the MV of NonOctalDigit.
The MV of NonOctalDecimalIntegerLiteral::LegacyOctalLikeDecimalIntegerLiteralNonOctalDigit is (the MV of LegacyOctalLikeDecimalIntegerLiteral times 10) plus the MV of NonOctalDigit.
The MV of NonOctalDecimalIntegerLiteral::NonOctalDecimalIntegerLiteralDecimalDigit is (the MV of NonOctalDecimalIntegerLiteral times 10) plus the MV of DecimalDigit.
The MV of LegacyOctalLikeDecimalIntegerLiteral::0OctalDigit is the MV of OctalDigit.
The MV of LegacyOctalLikeDecimalIntegerLiteral::LegacyOctalLikeDecimalIntegerLiteralOctalDigit is (the MV of LegacyOctalLikeDecimalIntegerLiteral times 10) plus the MV of OctalDigit.
The MV of NonOctalDigit::8 is 8.
The MV of NonOctalDigit::9 is 9.

B.1.2字符型字面量

除非这些扩展不被严格模式代码所允许，否则，11.8.4 中的语法和语义会被扩展如下：

Syntax

[lookahead ∉ OctalDigit]

ZeroToThree

SingleLineHTMLOpenComment

[lookahead ∉ OctalDigit]

one of

one of

This definition of EscapeSequence is not used in 严格模式 or when parsing TemplateCharacter.

B.1.2.1静态语义

The SV of EscapeSequence::LegacyOctalEscapeSequence is the SV of the LegacyOctalEscapeSequence.
The SV of LegacyOctalEscapeSequence::OctalDigit is the 代码单元 whose value is the MV of the OctalDigit.
The SV of LegacyOctalEscapeSequence::ZeroToThreeOctalDigit is the 代码单元 whose value is (8 times the MV of the ZeroToThree) plus the MV of the OctalDigit.
The SV of LegacyOctalEscapeSequence::FourToSevenOctalDigit is the 代码单元 whose value is (8 times the MV of the FourToSeven) plus the MV of the OctalDigit.
The SV of LegacyOctalEscapeSequence::ZeroToThreeOctalDigitOctalDigit is the 代码单元 whose value is (64 (that is, 8²) times the MV of the ZeroToThree) plus (8 times the MV of the first OctalDigit) plus the MV of the second OctalDigit.
The MV of ZeroToThree::0 is 0.
The MV of ZeroToThree::1 is 1.
The MV of ZeroToThree::2 is 2.
The MV of ZeroToThree::3 is 3.
The MV of FourToSeven::4 is 4.
The MV of FourToSeven::5 is 5.
The MV of FourToSeven::6 is 6.
The MV of FourToSeven::7 is 7.

B.1.3HTML-like 评论

除非这些扩展使用目标符模块来解析源代码时不会被允许，否则，11.4 中的语法和语义会被扩展如下：

Syntax

Comment

MultiLineComment

SingleLineComment

SingleLineHTMLCloseComment

SingleLineDelimitedComment

MultiLineComment

FirstCommentLine

opt

LineTerminator

opt

HTMLCloseComment

opt

FirstCommentLine

SingleLineHTMLOpenComment

<!--

SingleLineHTMLCloseComment

opt

SingleLineDelimitedComment

HTMLCloseComment

opt

HTMLCloseComment

SingleLineDelimitedCommentSequence

opt

opt

-->

opt

SingleLineNotAsteriskChar

SingleLinePostAsteriskCommentChars

opt

opt

SingleLineNotAsteriskChar

SingleLinePostAsteriskCommentChars

but not one of * or LineTerminator

SingleLineNotForwardSlashOrAsteriskChar

SingleLinePostAsteriskCommentChars

opt

opt

SingleLineNotForwardSlashOrAsteriskChar

but not one of / or * or LineTerminator

WhiteSpace

SingleLineDelimitedCommentSequence

opt

SingleLineDelimitedComment

SingleLineDelimitedCommentSequence

opt

opt

Similar to a MultiLineComment that contains a line terminator 码点, a SingleLineHTMLCloseComment is considered to be a LineTerminator for purposes of parsing by 句法.

B.1.4正则表达式模式

The syntax of 21.2.1 is modified and extended as follows. These changes introduce ambiguities that are broken by the ordering of grammar productions and by contextual information. When parsing using the following grammar, each alternative is considered only if previous production alternatives do not match.

This alternative pattern grammar and 语义 only changes the syntax and 语义 of BMP 模式. The following grammar extensions include productions parameterized with the [U] parameter. However, none of these extensions change the syntax of Unicode 模式 recognized when parsing with the [U] parameter present on the 目标符.

Syntax

Term

[U, N]

[+U]

Assertion

[+U, ?N]

[+U]

Atom

[+U, ?N]

[+U]

Atom

[+U, ?N]

[~U]

QuantifiableAssertion

[?N]

[~U]

Assertion

[~U, ?N]

[~U]

[?N]

[~U]

[?N]

[U, N]

[+U]

(

[+U, ?N]

)

[+U]

(

[+U, ?N]

)

[~U]

QuantifiableAssertion

[?N]

QuantifiableAssertion

[N]

(

[~U, ?N]

)

(

[~U, ?N]

)

ExtendedAtom

[N]

[~U, ?N]

[lookahead = c]

CharacterClass

[~U]

(

[~U, ?N]

)

(

[~U, ?N]

)

InvalidBracedQuantifier

ExtendedPatternCharacter

InvalidBracedQuantifier

{

}

{

}

{

}

ExtendedPatternCharacter

but not one of ^

(

)

[

[U, N]

[+U]

[~U]

but only if the 捕获分组号 of DecimalEscape is <= _NcapturingParens_

[?U]

[~U, ?N]

[+N]

[?U]

[U, N]

[lookahead ∉ DecimalDigit]

[?U]

[~U]

[?U, ?N]

[U, N]

[+U]

SourceCharacterIdentityEscape

[+U]

[~U]

[?N]

SourceCharacterIdentityEscape

[N]

[~N]

but not c

[+N]

but not one of c or k

[U, N]

but not one of \ or ] or -

[?U, ?N]

[lookahead = c]

[U, N]

[+U]

[~U]

[?U]

[?U, ?N]

Note

When the same left hand sides occurs with both [+U] and [~U] guards it is to control the disambiguation priority.

B.1.4.1静态语义: 早期错误

The 语义 of 21.2.1.1 is extended as follows:

ExtendedAtom

InvalidBracedQuantifier

这是一个句法错误如果 any 源文本 matches this rule.

NonemptyClassRanges

这是一个句法错误如果 IsCharacterClass of the first ClassAtom is true or IsCharacterClass of the second ClassAtom is true and this production has a _[U] parameter.

这是一个句法错误如果 IsCharacterClass of ClassAtomNoDash is true or IsCharacterClass of ClassAtom is true and this production has a _[U] parameter.

B.1.4.2静态语义: IsCharacterClass

The 语义 of 21.2.1.3 is extended as follows:

[lookahead = c]

Return false.

B.1.4.3静态语义: 字符值

The 语义 of 21.2.1.4 is extended as follows:

[lookahead = c]

Return the 码点 value of U+005C (REVERSE SOLIDUS).

ClassControlLetter

Let ch be the 码点 matched by ClassControlLetter.
Let i be ch's 码点 value.
Return the remainder of dividing i by 32.

Evaluate the SV of the LegacyOctalEscapeSequence (see B.1.2) to obtain a 代码单元 cu.
Return the 数字值 of cu.

B.1.4.4模式语义

The 语义 of 21.2.2 is extended as follows:

Within 21.2.2.5 reference to “ Atom::(GroupSpecifierDisjunction) ” are to be interpreted as meaning “ Atom::(GroupSpecifierDisjunction) ” or “ ExtendedAtom::(Disjunction) ”.

Term (21.2.2.5) includes the following additional 估值 rules:

The production Term::QuantifiableAssertionQuantifier evaluates the same as the production Term::AtomQuantifier but with QuantifiableAssertion substituted for Atom.

The production Term::ExtendedAtomQuantifier evaluates the same as the production Term::AtomQuantifier but with ExtendedAtom substituted for Atom.

The production Term::ExtendedAtom evaluates the same as the production Term::Atom but with ExtendedAtom substituted for Atom.

Assertion (21.2.2.6) includes the following additional 估值 rule:

The production Assertion::QuantifiableAssertion evaluates as follows:

Evaluate QuantifiableAssertion to obtain a Matcher m.
Return m.

Assertion (21.2.2.6) 估值 rules for the Assertion::(?=Disjunction) and Assertion::(?!Disjunction) productions are also used for the QuantifiableAssertion productions, but with QuantifiableAssertion substituted for Assertion.

Atom (21.2.2.8) 估值 rules for the Atom productions except for Atom::PatternCharacter are also used for the ExtendedAtom productions, but with ExtendedAtom substituted for Atom. The following 估值 rules are also added:

The production ExtendedAtom::\[lookahead = c] evaluates as follows:

Let A be the CharSet containing the single character \ U+005C (REVERSE SOLIDUS).
Call CharacterSetMatcher(A, false) and return its Matcher result.

The production ExtendedAtom::ExtendedPatternCharacter evaluates as follows:

Let ch be the character represented by ExtendedPatternCharacter.
Let A be a one-element CharSet containing the character ch.
Call CharacterSetMatcher(A, false) and return its Matcher result.

CharacterEscape (21.2.2.10) includes the following additional 估值 rule:

The production CharacterEscape::LegacyOctalEscapeSequence evaluates as follows:

Let cv be the 字符值 of this CharacterEscape.
Return the character whose character value is cv.

NonemptyClassRanges (21.2.2.15) modifies the following 估值 rule:

The production NonemptyClassRanges::ClassAtom-ClassAtomClassRanges evaluates as follows:

Evaluate the first ClassAtom to obtain a CharSet A.
Evaluate the second ClassAtom to obtain a CharSet B.
Evaluate ClassRanges to obtain a CharSet C.
Call CharacterRangeOrUnion(A, B) and let D be the resulting CharSet.
Return the union of CharSets D and C.

NonemptyClassRangesNoDash (21.2.2.16) modifies the following 估值 rule:

The production NonemptyClassRangesNoDash::ClassAtomNoDash-ClassAtomClassRanges evaluates as follows:

Evaluate ClassAtomNoDash to obtain a CharSet A.
Evaluate ClassAtom to obtain a CharSet B.
Evaluate ClassRanges to obtain a CharSet C.
Call CharacterRangeOrUnion(A, B) and let D be the resulting CharSet.
Return the union of CharSets D and C.

ClassEscape (21.2.2.19) includes the following additional 估值 rule:

The production ClassEscape::cClassControlLetter evaluates as follows:

Let cv be the 字符值 of this ClassEscape.
Let c be the character whose character value is cv.
Return the CharSet containing the single character c.

ClassAtomNoDash (21.2.2.18) includes the following additional 估值 rule:

The production ClassAtomNoDash::\[lookahead = c] evaluates as follows:

Return the CharSet containing the single character \ U+005C (REVERSE SOLIDUS).

Note

This production can only be reached from the sequence \c within a character class where it is not followed by an acceptable control character.

B.1.4.4.1运行时语义: CharacterRangeOrUnion ( `A`, `B` )

The 抽象操作 CharacterRangeOrUnion takes two CharSet parameters A and B and 执行如下:

If Unicode is false, then
1. If A does not contain exactly one character or B does not contain exactly one character, then
  1. Let C be the CharSet containing the single character - U+002D (HYPHEN-MINUS).
  2. Return the union of CharSets A, B and C.
Return CharacterRange(A, B).

B.2附加的内置属性

当 ES 宿主是 web 浏览器时，以下标准内置对象额外的属性会被定义如下。

B.2.1全局对象的附加属性

The entries in Table 79 are added to Table 7.

Table 79: Additional 众所周知的内部对象

Intrinsic Name	Global Name	ES Language Association
%escape%	`escape`	The `escape` function (B.2.1.1)
%unescape%	`unescape`	The `unescape` function (B.2.1.2)

B.2.1.1escape ( `string` )

The escape function is a property of the 全局对象. It computes a new version of a String 值 in which certain 代码单元 have been replaced by a hexadecimal escape sequence.

For those 代码单元 being replaced whose value is 0x00FF or less, a two-digit escape sequence of the form %xx is used. For those characters being replaced whose 代码单元 value is greater than 0x00FF, a four-digit escape sequence of the form %uxxxx is used.

The escape function is the %escape% 内部对象. When the escape function is called with one argument string, 执行如下:

Set string to ? ToString(string).
Let length be the number of 代码单元 in string.
Let R be the empty string.
Let k be 0.
Repeat, while k < length,
1. Let char be the 代码单元 (represented as a 16-bit unsigned integer) at index k within string.
2. If char is one of the 代码单元 in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@*_+-./", then
  1. Let S be the String 值 containing the single 代码单元 char.
3. Else if char ≥ 256, then
  1. Let S be the string-concatenation of "%u" and the four uppercase hexadecimal digits encoding char.
4. Else char < 256,
  1. Let S be the string-concatenation of "%" and the two uppercase hexadecimal digits encoding char.
5. Set R to the string-concatenation of the previous value of R and S.
6. Increase k by 1.
Return R.

Note

The encoding is partly based on the encoding described in RFC 1738, but the entire encoding specified in this standard is described above without regard to the contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC 3986.

B.2.1.2unescape ( `string` )

The unescape function is a property of the 全局对象. It computes a new version of a String 值 in which each escape sequence of the sort that might be introduced by the escape function is replaced with the 代码单元 that it represents.

The unescape function is the %unescape% 内部对象. When the unescape function is called with one argument string, 执行如下:

Set string to ? ToString(string).
Let length be the number of 代码单元 in string.
Let R be the empty String.
Let k be 0.
Repeat, while k ≠ length
1. Let c be the 代码单元 at index k within string.
2. If c is the 代码单元 0x0025 (PERCENT SIGN), then
  1. If k ≤ length-6 and the 代码单元 at index k+1 within string is the 代码单元 0x0075 (LATIN SMALL LETTER U) and the four 代码单元 at indices k+2, k+3, k+4, and k+5 within string are all hexadecimal digits, then
    1. Let c be the 代码单元 whose value is the integer represented by the four hexadecimal digits at indices k+2, k+3, k+4, and k+5 within string.
    2. Increase k by 5.
  2. Else if k ≤ length-3 and the two 代码单元 at indices k+1 and k+2 within string are both hexadecimal digits, then
    1. Let c be the 代码单元 whose value is the integer represented by two zeroes plus the two hexadecimal digits at indices k+1 and k+2 within string.
    2. Increase k by 2.
3. Set R to the string-concatenation of the previous value of R and c.
4. Increase k by 1.
Return R.

B.2.2Object.prototype 对象的附加属性

B.2.2.1Object.prototype.proto

Object.prototype.__proto__ is an 访问器属性 with 特性 { [[Enumerable]]: false, [[Configurable]]: true }. The [[Get]] and [[Set]] 特性 are defined as follows:

B.2.2.1.1get Object.prototype.proto

The value of the [[Get]] 特性 is a 内置函数 that requires no arguments. It 执行如下:

Let O be ? ToObject(this value).
Return ? O.[[GetPrototypeOf]]().

B.2.2.1.2set Object.prototype.proto

The value of the [[Set]] 特性 is a 内置函数 that takes an argument proto. It 执行如下:

Let O be ? RequireObjectCoercible(this value).
If Type(proto) is neither Object nor Null, return undefined.
If Type(O) is not Object, return undefined.
Let status be ? O.[[SetPrototypeOf]](proto).
If status is false, 抛出一个 TypeError 异常.
Return undefined.

B.2.2.2Object.prototype.defineGetter ( `P`, `getter` )

When the __defineGetter__ method is called with arguments P and getter, 执行如下:

Let O be ? ToObject(this value).
If IsCallable(getter) is false, 抛出一个 TypeError 异常.
Let desc be PropertyDescriptor{[[Get]]: getter, [[Enumerable]]: true, [[Configurable]]: true}.
Let key be ? ToPropertyKey(P).
Perform ? DefinePropertyOrThrow(O, key, desc).
Return undefined.

B.2.2.3Object.prototype.defineSetter ( `P`, `setter` )

When the __defineSetter__ method is called with arguments P and setter, 执行如下:

Let O be ? ToObject(this value).
If IsCallable(setter) is false, 抛出一个 TypeError 异常.
Let desc be PropertyDescriptor{[[Set]]: setter, [[Enumerable]]: true, [[Configurable]]: true}.
Let key be ? ToPropertyKey(P).
Perform ? DefinePropertyOrThrow(O, key, desc).
Return undefined.

B.2.2.4Object.prototype.lookupGetter ( `P` )

When the __lookupGetter__ method is called with argument P, 执行如下:

Let O be ? ToObject(this value).
Let key be ? ToPropertyKey(P).
Repeat,
1. Let desc be ? O.[[GetOwnProperty]](key).
2. If desc is not undefined, then
  1. If IsAccessorDescriptor(desc) is true, return desc.[[Get]].
  2. Return undefined.
3. Set O to ? O.[[GetPrototypeOf]]().
4. If O is null, return undefined.

B.2.2.5Object.prototype.lookupSetter ( `P` )

When the __lookupSetter__ method is called with argument P, 执行如下:

Let O be ? ToObject(this value).
Let key be ? ToPropertyKey(P).
Repeat,
1. Let desc be ? O.[[GetOwnProperty]](key).
2. If desc is not undefined, then
  1. If IsAccessorDescriptor(desc) is true, return desc.[[Set]].
  2. Return undefined.
3. Set O to ? O.[[GetPrototypeOf]]().
4. If O is null, return undefined.

B.2.3String.prototype 对象的附加属性

B.2.3.1String.prototype.substr ( `start`, `length` )

The substr method takes two arguments, start and length, and returns a substring of the result of converting the this object to a String, starting from index start and running for length 代码单元 (or through the end of the String if length is undefined). If start is negative, it is treated as sourceLength+start where sourceLength is the length of the String. 结果是一个 String 值, 而不是一个 String 对象. 执行如下:

Let O be ? RequireObjectCoercible(this value).
Let S be ? ToString(O).
Let intStart be ? ToInteger(start).
If length is undefined, let end be +∞; otherwise let end be ? ToInteger(length).
Let size be the number of 代码单元 in S.
If intStart < 0, let intStart be max(size + intStart, 0).
Let resultLength be min(max(end, 0), size - intStart).
If resultLength ≤ 0, return the empty String "".
Return the String 值 containing resultLength consecutive 代码单元 from S beginning with the 代码单元 at index intStart.

Note

The substr function 是故意通用的; 不需要 its this value be a String 对象. Therefore 它可以转换为其它对象类型的方法而被使用.

B.2.3.2String.prototype.anchor ( `name` )

When the anchor method is called with argument name, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "a", "name", name).

B.2.3.2.1运行时语义: CreateHTML ( `string`, `tag`, `特性`, `value` )

The 抽象操作 CreateHTML is called with arguments string, tag, 特性, and value. The arguments tag and 特性 must be String values. 执行如下:

Let str be ? RequireObjectCoercible(string).
Let S be ? ToString(str).
Let p1 be the string-concatenation of "<" and tag.
If 特性 is not the empty String, then
1. Let V be ? ToString(value).
2. Let escapedV be the String 值 that is the same as V except that each occurrence of the 代码单元 0x0022 (QUOTATION MARK) in V has been replaced with the six 代码单元 sequence """.
3. Set p1 to the string-concatenation of:
  - p1
  - the 代码单元 0x0020 (SPACE)
  - 特性
  - the 代码单元 0x003D (EQUALS SIGN)
  - the 代码单元 0x0022 (QUOTATION MARK)
  - escapedV
  - the 代码单元 0x0022 (QUOTATION MARK)
Let p2 be the string-concatenation of p1 and ">".
Let p3 be the string-concatenation of p2 and S.
Let p4 be the string-concatenation of p3, "</", tag, and ">".
Return p4.

B.2.3.3String.prototype.big ( )

When the big method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "big", "", "").

B.2.3.4String.prototype.blink ( )

When the blink method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "blink", "", "").

B.2.3.5String.prototype.bold ( )

When the bold method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "b", "", "").

B.2.3.6String.prototype.fixed ( )

When the fixed method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "tt", "", "").

B.2.3.7String.prototype.fontcolor ( `color` )

When the fontcolor method is called with argument color, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "font", "color", color).

B.2.3.8String.prototype.fontsize ( `size` )

When the fontsize method is called with argument size, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "font", "size", size).

B.2.3.9String.prototype.italics ( )

When the italics method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "i", "", "").

B.2.3.10String.prototype.link ( `url` )

When the link method is called with argument url, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "a", "href", url).

B.2.3.11String.prototype.small ( )

When the small method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "small", "", "").

B.2.3.12String.prototype.strike ( )

When the strike method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "strike", "", "").

B.2.3.13String.prototype.sub ( )

When the sub method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "sub", "", "").

B.2.3.14String.prototype.sup ( )

When the sup method is called with no arguments, 执行如下:

Let S be the this value.
Return ? CreateHTML(S, "sup", "", "").

B.2.4Date.prototype 对象的附加属性

B.2.4.1Date.prototype.getYear ( )

Note

The getFullYear method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”

When the getYear method is called with no arguments, 执行如下:

Let t be ? thisTimeValue(this value).
If t is NaN, return NaN.
Return YearFromTime(LocalTime(t)) - 1900.

B.2.4.2Date.prototype.setYear ( `year` )

Note

The setFullYear method is preferred for nearly all purposes, because it avoids the “year 2000 problem.”

When the setYear method is called with one argument year, 执行如下:

Let t be ? thisTimeValue(this value).
If t is NaN, let t be +0; otherwise, let t be LocalTime(t).
Let y be ? ToNumber(year).
If y is NaN, set the [[DateValue]] 内部属性 of this Date object to NaN and return NaN.
If 0 ≤ ToInteger(y) ≤ 99, let yyyy be ToInteger(y) + 1900.
Else, let yyyy be y.
Let d be MakeDay(yyyy, MonthFromTime(t), DateFromTime(t)).
Let date be UTC(MakeDate(d, TimeWithinDay(t))).
Set the [[DateValue]] 内部属性 of this Date object to TimeClip(date).
Return the value of the [[DateValue]] 内部属性 of this Date object.

B.2.4.3Date.prototype.toGMTString ( )

Note

The property toUTCString is preferred. The toGMTString property is provided principally for compatibility with old code. It is recommended that the toUTCString property be used in new ES 代码.

The 函数对象 that is the 初始值 of Date.prototype.toGMTString is the same 函数对象 that is the 初始值 of Date.prototype.toUTCString.

B.2.5RegExp.prototype 对象的附加属性

B.2.5.1RegExp.prototype.compile ( `pattern`, `flags` )

When the compile method is called with arguments pattern and flags, 执行如下:

Let O be the this value.
If Type(O) is not Object or Type(O) is Object and O does not have a [[RegExpMatcher]] 内部属性, then
1. 抛出一个 TypeError 异常.
If Type(pattern) is Object and pattern has a [[RegExpMatcher]] 内部属性, then
1. If flags is not undefined, 抛出一个 TypeError 异常.
2. Let P be pattern.[[OriginalSource]].
3. Let F be pattern.[[OriginalFlags]].
Else,
1. Let P be pattern.
2. Let F be flags.
Return ? RegExpInitialize(O, P, F).

Note

The compile method completely reinitializes the this object RegExp with a new pattern and flags. An 实现 may interpret use of this method as an assertion that the resulting RegExp 对象 will be used multiple times and hence is a candidate for extra optimization.

B.3其他附加特征

B.3.1函数初始化器中的 proto 名

The following 早期错误 rule is added to those in 12.2.6.1. When ObjectLiteral appears in a context where ObjectAssignmentPattern is required the 早期错误 rule is not applied. In addition, it is not applied when initially parsing a CoverParenthesizedExpressionAndArrowParameterList or a CoverCallExpressionAndAsyncArrowHead.

{

}

{

}

这是一个句法错误如果属性名列表 of PropertyDefinitionList contains any duplicate entries for "__proto__" and at least two of those entries were obtained from productions of the form PropertyDefinition:PropertyName:AssignmentExpression .

Note

The List returned by 属性名列表 does not include string literal property names defined as using a ComputedPropertyName.

In 12.2.6.8 the 属性定义估值算法 for the production
PropertyDefinition:PropertyName:AssignmentExpression
is replaced with the following definition:

Let propKey be the result of evaluating PropertyName.
ReturnIfAbrupt(propKey).
Let exprValueRef be the result of evaluating AssignmentExpression.
Let propValue be ? GetValue(exprValueRef).
If propKey is the String 值 "__proto__" and if IsComputedPropertyKey(PropertyName) is false, then
1. If Type(propValue) is either Object or Null, then
  1. Return object.[[SetPrototypeOf]](propValue).
2. Return NormalCompletion(empty).
If IsAnonymousFunctionDefinition(AssignmentExpression) is true, then
1. Let hasNameProperty be ? HasOwnProperty(propValue, "name").
2. If hasNameProperty is false, perform SetFunctionName(propValue, propKey).
Assert: enumerable is true.
Return CreateDataPropertyOrThrow(object, propKey, propValue).

B.3.2标签函数声明

Prior to ES 2015, the specification of LabelledStatement did not allow for the association of a statement label with a FunctionDeclaration. However, a labelled FunctionDeclaration was an allowable extension for non-strict code and most browser-hosted ES implementations supported that extension. In ES 2015, the grammar productions for LabelledStatement permits use of FunctionDeclaration as a LabelledItem but 13.13.1 includes an 早期错误 rule that produces a Syntax Error if that occurs. For web browser compatibility, that rule is modified with the addition of the highlighted text:

这是一个句法错误如果 any 严格模式 source code matches this rule.

Note

The 早期错误 rules for WithStatement, IfStatement, and IterationStatement prevent these statements from containing a labelled FunctionDeclaration in non-strict code.

B.3.3Block-Level 函数声明 Web Legacy Compatibility 语义

Prior to ES 2015, the ES specification did not define the occurrence of a FunctionDeclaration as an element of a Block statement's StatementList. However, support for that form of FunctionDeclaration was an allowable extension and most browser-hosted ES implementations permitted them. Unfortunately, the 语义 of such declarations differ among those implementations. Because of these semantic differences, existing web ES 代码 that uses Block level 函数声明 is only portable among browser 实现 if the usage only depends upon the semantic intersection of all of the browser implementations for such declarations. The following are the use cases that fall within that intersection 语义:

A function is declared and only referenced within a single block
- One or more FunctionDeclarations whose BindingIdentifier is the name f occur within the function code of an enclosing function g and that declaration is nested within a Block.
- No other declaration of f that is not a var declaration occurs within the function code of g
- All occurrences of f as an IdentifierReference are within the StatementList of the Block containing the declaration of f.
A function is declared and possibly used within a single Block but also referenced by an inner function definition that is not contained within that same Block.
- One or more FunctionDeclarations whose BindingIdentifier is the name f occur within the function code of an enclosing function g and that declaration is nested within a Block.
- No other declaration of f that is not a var declaration occurs within the function code of g
- There may be occurrences of f as an IdentifierReference within the StatementList of the Block containing the declaration of f.
- There is at least one occurrence of f as an IdentifierReference within another function h that is nested within g and no other declaration of f shadows the references to f from within h.
- All invocations of h occur after the declaration of f has been evaluated.
A function is declared and possibly used within a single block but also referenced within subsequent blocks.
- One or more FunctionDeclaration whose BindingIdentifier is the name f occur within the function code of an enclosing function g and that declaration is nested within a Block.
- No other declaration of f that is not a var declaration occurs within the function code of g
- There may be occurrences of f as an IdentifierReference within the StatementList of the Block containing the declaration of f.
- There is at least one occurrence of f as an IdentifierReference within the function code of g that lexically follows the Block containing the declaration of f.

The first use case is interoperable with the 语义 of Block level 函数声明 provided by ES 2015. Any pre-existing ES 代码 that employs that use case will operate using the Block level 函数声明语义 defined by clauses 9, 13, and 14 of this specification.

ES 2015 interoperability for the second and third use cases requires the following extensions to the clause 9, clause 14, clause 18.2.1 and clause 15.1.11 语义.

If an ES 实现 has a mechanism for reporting diagnostic warning messages, a warning should be produced when code contains a FunctionDeclaration for which these compatibility 语义 are applied and introduce observable differences from non-compatibility 语义. 例如, if a var binding is not introduced because its 引言 would create an 早期错误, a warning message should not be produced.

B.3.3.1Changes to FunctionDeclarationInstantiation

During FunctionDeclarationInstantiation the following steps are performed in place of step 28:

If strict is false, then
1. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause, do
  1. Let F be 字符值 of the BindingIdentifier of FunctionDeclaration f.
  2. If replacing the FunctionDeclaration f with a VariableStatement that has F as a BindingIdentifier would not produce any 早期错误 for func and F is not an element of parameterNames, then
    1. NOTE: A var binding for F is only instantiated here if it is neither a VarDeclaredName, the name of a formal parameter, or another FunctionDeclaration.
    2. If initializedBindings does not contain F and F is not "arguments", then
      1. Perform ! varEnvRec.CreateMutableBinding(F, false).
      2. Perform varEnvRec.InitializeBinding(F, undefined).
      3. Append F to instantiatedVarNames.
    3. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration 估值算法 provided in 14.1.21:
      1. Let fenv be the 运行时执行上下文's VariableEnvironment.
      2. Let fenvRec be fenv's EnvironmentRecord.
      3. Let benv be the 运行时执行上下文's LexicalEnvironment.
      4. Let benvRec be benv's EnvironmentRecord.
      5. Let fobj be ! benvRec.GetBindingValue(F, false).
      6. Perform ! fenvRec.SetMutableBinding(F, fobj, false).
      7. Return NormalCompletion(empty).

B.3.3.2Changes to GlobalDeclarationInstantiation

During GlobalDeclarationInstantiation the following steps are performed in place of step 14:

Let strict be IsStrict of script.
If strict is false, then
1. Let declaredFunctionOrVarNames be a new empty List.
2. Append to declaredFunctionOrVarNames the elements of declaredFunctionNames.
3. Append to declaredFunctionOrVarNames the elements of declaredVarNames.
4. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause Contained within script, do
  1. Let F be 字符值 of the BindingIdentifier of FunctionDeclaration f.
  2. If replacing the FunctionDeclaration f with a VariableStatement that has F as a BindingIdentifier would not produce any 早期错误 for script, then
    1. If envRec.HasLexicalDeclaration(F) is false, then
      1. Let fnDefinable be ? envRec.CanDeclareGlobalFunction(F).
      2. If fnDefinable is true, then
        NOTE: A var binding for F is only instantiated here if it is neither a VarDeclaredName nor the name of another FunctionDeclaration.
        If declaredFunctionOrVarNames does not contain F, then
        Perform ? envRec.CreateGlobalFunctionBinding(F, undefined, false).
        Append F to declaredFunctionOrVarNames.
        When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration 估值算法 provided in 14.1.21:
        Let genv be the 运行时执行上下文's VariableEnvironment.
        Let genvRec be genv's EnvironmentRecord.
        Let benv be the 运行时执行上下文's LexicalEnvironment.
        Let benvRec be benv's EnvironmentRecord.
        Let fobj be ! benvRec.GetBindingValue(F, false).
        Perform ? genvRec.SetMutableBinding(F, fobj, false).
        Return NormalCompletion(empty).

B.3.3.3Changes to EvalDeclarationInstantiation

During EvalDeclarationInstantiation the following steps are performed in place of step 9:

If strict is false, then
1. Let declaredFunctionOrVarNames be a new empty List.
2. Append to declaredFunctionOrVarNames the elements of declaredFunctionNames.
3. Append to declaredFunctionOrVarNames the elements of declaredVarNames.
4. For each FunctionDeclaration f that is directly contained in the StatementList of a Block, CaseClause, or DefaultClause Contained within body, do
  1. Let F be 字符值 of the BindingIdentifier of FunctionDeclaration f.
  2. If replacing the FunctionDeclaration f with a VariableStatement that has F as a BindingIdentifier would not produce any 早期错误 for body, then
    1. Let bindingExists be false.
    2. Let thisLex be lexEnv.
    3. Assert: The following loop will terminate.
    4. Repeat, while thisLex is not the same as varEnv,
      1. Let thisEnvRec be thisLex's EnvironmentRecord.
      2. If thisEnvRec is not an object 环境记录, then
        If thisEnvRec.HasBinding(F) is true, then
        Let bindingExists be true.
      3. Let thisLex be thisLex's outer environment reference.
    5. If bindingExists is false and varEnvRec is a global 环境记录, then
      1. If varEnvRec.HasLexicalDeclaration(F) is false, then
        Let fnDefinable be ? varEnvRec.CanDeclareGlobalFunction(F).
      2. Else,
        Let fnDefinable be false.
    6. Else,
      1. Let fnDefinable be true.
    7. If bindingExists is false and fnDefinable is true, then
      1. If declaredFunctionOrVarNames does not contain F, then
        If varEnvRec is a global 环境记录, then
        Perform ? varEnvRec.CreateGlobalFunctionBinding(F, undefined, true).
        Else,
        Let bindingExists be varEnvRec.HasBinding(F).
        If bindingExists is false, then
        Perform ! varEnvRec.CreateMutableBinding(F, true).
        Perform ! varEnvRec.InitializeBinding(F, undefined).
        Append F to declaredFunctionOrVarNames.
      2. When the FunctionDeclaration f is evaluated, perform the following steps in place of the FunctionDeclaration 估值算法 provided in 14.1.21:
        Let genv be the 运行时执行上下文's VariableEnvironment.
        Let genvRec be genv's EnvironmentRecord.
        Let benv be the 运行时执行上下文's LexicalEnvironment.
        Let benvRec be benv's EnvironmentRecord.
        Let fobj be ! benvRec.GetBindingValue(F, false).
        Perform ? genvRec.SetMutableBinding(F, fobj, false).
        Return NormalCompletion(empty).

B.3.3.4Changes to Block 静态语义: 早期错误

For web browser compatibility, that rule is modified with the addition of the highlighted text:

{

}

这是一个句法错误如果 the LexicallyDeclaredNames of StatementList contains any duplicate entries, unless the source code matching this production is not 严格模式代码 and the duplicate entries are only bound by FunctionDeclarations.

B.3.3.5Changes to `switch` Statement 静态语义: 早期错误

For web browser compatibility, that rule is modified with the addition of the highlighted text:

switch

(

)

这是一个句法错误如果 the LexicallyDeclaredNames of CaseBlock contains any duplicate entries, unless the source code matching this production is not 严格模式代码 and the duplicate entries are only bound by FunctionDeclarations.

B.3.3.6Changes to BlockDeclarationInstantiation

During BlockDeclarationInstantiation the following steps are performed in place of step 4.a.ii.1:

If envRec.HasBinding(dn) is false, then
1. Perform ! envRec.CreateMutableBinding(dn, false).

During BlockDeclarationInstantiation the following steps are performed in place of step 4.b.iii:

If envRec.HasBinding(fn) is false, then
1. Perform envRec.InitializeBinding(fn, fo).
Else,
1. Assert: d is a FunctionDeclaration.
2. Perform envRec.SetMutableBinding(fn, fo, false).

B.3.4FunctionDeclarations in IfStatement Statement Clauses

The following augments the IfStatement production in 13.6:

[Yield, Await, Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ~Default]

else

[?Yield, ?Await, ?Return]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

else

[?Yield, ?Await, ~Default]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ~Default]

else

[?Yield, ?Await, ~Default]

(

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ~Default]

This production only applies when parsing non-strict code. Code matching this production is processed as if each matching occurrence of FunctionDeclaration[?Yield, ?Await, ~Default] was the sole StatementListItem of a BlockStatement occupying that position in the source code. The 语义 of such a synthetic BlockStatement includes the web legacy compatibility 语义 specified in B.3.3.

B.3.5VariableStatements in Catch Blocks

The content of subclause 13.15.1 is replaced with the following:

catch

(

)

这是一个句法错误如果绑定名 of CatchParameter contains any duplicate elements.
这是一个句法错误如果 any element of the 绑定名 of CatchParameter also occurs in the LexicallyDeclaredNames of Block.
这是一个句法错误如果 any element of the 绑定名 of CatchParameter also occurs in the VarDeclaredNames of Block unless CatchParameter is CatchParameter:BindingIdentifier and that element is only bound by a VariableStatement, the VariableDeclarationList of a for statement, the ForBinding of a for-in statement, or the BindingIdentifier of a for-in statement.

Note

The Block of a Catch clause may contain var declarations that bind a name that is also bound by the CatchParameter. At runtime, such bindings are instantiated in the VariableDeclarationEnvironment. They do not shadow the same-named bindings introduced by the CatchParameter and hence the 初始化器 for such var declarations will assign to the corresponding catch parameter rather than the var binding. The relaxation of the normal 静态语义规则 does not apply to names only bound by for-of statements.

This modified behaviour also applies to var and function declarations introduced by direct eval calls contained within the Block of a Catch clause. This change is accomplished by modifying the 算法 of 18.2.1.3 as follows:

Step 5.d.ii.2.a.i is replaced by:

If thisEnvRec is not the 环境记录 for a Catch clause, 抛出一个 SyntaxError 异常.
If name is bound by any syntactic form other than a FunctionDeclaration, a VariableStatement, the VariableDeclarationList of a for statement, the ForBinding of a for-in statement, or the BindingIdentifier of a for-in statement, 抛出一个 SyntaxError 异常.

Step 9.d.ii.4.b.i.i is replaced by:

If thisEnvRec is not the 环境记录 for a Catch clause, let bindingExists be true.

B.3.6初始化器 in ForIn Statement Heads

The following augments the IterationStatement production in 13.7:

[Yield, Await, Return]

for

(

var

[?Yield, ?Await]

[~In, ?Yield, ?Await]

[+In, ?Yield, ?Await]

)

[?Yield, ?Await, ?Return]

This production only applies when parsing non-strict code.

The 静态语义 of ContainsDuplicateLabels in 13.7.5.3 are augmented with the following:

for

(

var

)

Return ContainsDuplicateLabels of Statement with argument labelSet.

The 静态语义 of ContainsUndefinedBreakTarget in 13.7.5.4 are augmented with the following:

for

(

var

)

Return ContainsUndefinedBreakTarget of Statement with argument labelSet.

The 静态语义 of ContainsUndefinedContinueTarget in 13.7.5.5 are augmented with the following:

for

(

var

)

Return ContainsUndefinedContinueTarget of Statement with arguments iterationSet and « ».

The 静态语义 of 是解构 in 13.7.5.6 are augmented with the following:

yield

await

Return false.

The 静态语义 of VarDeclaredNames in 13.7.5.7 are augmented with the following:

for

(

var

)

Let names be the 绑定名 of BindingIdentifier.
Append to names the elements of the VarDeclaredNames of Statement.
Return names.

The 静态语义 of VarScopedDeclarations in 13.7.5.8 are augmented with the following:

for

(

var

)

Let declarations be a List containing BindingIdentifier.
Append to declarations the elements of the VarScopedDeclarations of Statement.
Return declarations.

The 运行时语义 of LabelledEvaluation in 13.7.5.11 are augmented with the following: